@aifabrix/builder 2.22.2 → 2.31.1

package/lib/utils/deployment-errors.js

@@ -42,127 +42,195 @@ function handleDeploymentError(error) {
 }
 
 /**
- * Unified error handler for deployment errors
- * Handles audit logging, error formatting, and user-friendly messages
- * @param {Error} error - Error object
- * @param {string} appName - Application name for audit logging
- * @param {string} url - Controller URL for audit logging
- * @param {boolean} [alreadyLogged=false] - Whether error has already been logged
- * @throws {Error} User-friendly error message
+ * Extract error message from different error types
+ * @param {Error|string|Object} error - Error object, string, or object
+ * @returns {string} Error message
  */
-async function handleDeploymentErrors(error, appName, url, alreadyLogged = false) {
-  // For validation errors (like URL validation), just re-throw them directly
-  // They already have user-friendly messages
-  // Handle both Error objects and strings
-  let errorMessage = '';
+function extractErrorMessage(error) {
   if (error instanceof Error) {
-    errorMessage = error.message || '';
-  } else if (typeof error === 'string') {
-    errorMessage = error;
-  } else if (error && typeof error === 'object' && error.message) {
-    errorMessage = error.message;
+    return error.message || '';
+  }
+  if (typeof error === 'string') {
+    return error;
   }
+  if (error && typeof error === 'object' && error.message) {
+    return error.message;
+  }
+  return '';
+}
 
-  if (errorMessage && (
+/**
+ * Check if error is a validation error that should be re-thrown directly
+ * @param {string} errorMessage - Error message
+ * @returns {boolean} True if validation error
+ */
+function isValidationError(errorMessage) {
+  return errorMessage && (
     errorMessage.includes('Controller URL must use HTTPS') ||
     errorMessage.includes('Invalid environment key') ||
     errorMessage.includes('Environment key is required') ||
     errorMessage.includes('Authentication configuration is required') ||
     errorMessage.includes('Invalid controller URL format') ||
     errorMessage.includes('Controller URL is required')
-  )) {
-    // If error is a string, convert to Error object
-    if (typeof error === 'string') {
-      throw new Error(error);
-    }
-    // If it's already an Error object, re-throw it directly
-    if (error instanceof Error) {
-      throw error;
-    }
-    // Otherwise, create a new Error with the message
-    throw new Error(errorMessage);
-  }
+  );
+}
 
-  // Log to audit log if not already logged
-  if (!alreadyLogged) {
-    try {
-      await auditLogger.logDeploymentFailure(appName, url, error);
-    } catch (logError) {
-      // Don't fail if audit logging fails, but log to console
-      // eslint-disable-next-line no-console
-      console.error(`[AUDIT LOG ERROR] Failed to log deployment failure: ${logError.message}`);
-    }
+/**
+ * Re-throw validation errors directly
+ * @param {Error|string|Object} error - Error object
+ * @param {string} errorMessage - Error message
+ * @throws {Error} Validation error
+ */
+function throwValidationError(error, errorMessage) {
+  if (typeof error === 'string') {
+    throw new Error(error);
+  }
+  if (error instanceof Error) {
+    throw error;
   }
+  throw new Error(errorMessage);
+}
 
-  const safeError = handleDeploymentError(error);
+/**
+ * Log deployment failure to audit log
+ * @async
+ * @param {string} appName - Application name
+ * @param {string} url - Controller URL
+ * @param {Error|string|Object} error - Error object
+ * @returns {Promise<void>}
+ */
+async function logDeploymentFailure(appName, url, error) {
+  try {
+    await auditLogger.logDeploymentFailure(appName, url, error);
+  } catch (logError) {
+    // Don't fail if audit logging fails, but log to console
+    // eslint-disable-next-line no-console
+    console.error(`[AUDIT LOG ERROR] Failed to log deployment failure: ${logError.message}`);
+  }
+}
 
-  // Extract error data from axios response
+/**
+ * Extract and normalize error response data
+ * @param {Object} safeError - Safe error object
+ * @param {Error|Object} error - Original error object
+ * @returns {string|Object} Normalized error response
+ */
+function extractErrorResponse(safeError, error) {
   let errorData = safeError.data;
   if (error.response && error.response.data !== undefined) {
     errorData = error.response.data;
   }
 
-  // Ensure errorData is not undefined before parsing
-  // If errorData is undefined, use the error message instead
   let errorResponse = errorData !== undefined ? errorData : safeError.message;
 
-  // Ensure errorResponse is a string or object, not an Error object
   if (errorResponse instanceof Error) {
     errorResponse = errorResponse.message || 'Unknown error occurred';
   }
 
-  // Ensure errorResponse is not null or undefined
   if (errorResponse === null || errorResponse === undefined) {
     errorResponse = safeError.message || 'Unknown error occurred';
   }
 
-  // Determine if this is a network error
-  const isNetworkError = safeError.code === 'ECONNREFUSED' ||
+  return errorResponse;
+}
+
+/**
+ * Determine if error is a network error
+ * @param {Object} safeError - Safe error object
+ * @returns {boolean} True if network error
+ */
+function isNetworkError(safeError) {
+  return safeError.code === 'ECONNREFUSED' ||
     safeError.code === 'ENOTFOUND' ||
     safeError.code === 'ECONNABORTED' ||
     safeError.timeout;
+}
+
+/**
+ * Parse error response and ensure valid result
+ * @param {string|Object} errorResponse - Error response
+ * @param {Object} safeError - Safe error object
+ * @returns {Object} Parsed error object
+ */
+function parseErrorResponseSafely(errorResponse, safeError) {
+  const isNetwork = isNetworkError(safeError);
 
-  // Parse error using error handler
-  let parsedError;
   try {
-    parsedError = parseErrorResponse(errorResponse, safeError.status || 0, isNetworkError);
-    // Ensure parsedError is a valid object
+    const parsedError = parseErrorResponse(errorResponse, safeError.status || 0, isNetwork);
     if (!parsedError || typeof parsedError !== 'object') {
       throw new Error('parseErrorResponse returned invalid result');
     }
-  } catch (parseErr) {
-    // If parsing fails, use the safe error message
-    parsedError = {
-      message: safeError.message || 'Unknown error occurred',
-      formatted: safeError.message || 'Unknown error occurred',
-      data: undefined
-    };
-  }
-
-  // Ensure parsedError is always a valid object with required properties
-  if (!parsedError || typeof parsedError !== 'object') {
-    parsedError = {
+    return parsedError;
+  } catch {
+    return {
       message: safeError.message || 'Unknown error occurred',
       formatted: safeError.message || 'Unknown error occurred',
       data: undefined
     };
   }
+}
 
-  // Ensure we have a message - handle case where parsedError.message might be undefined
+/**
+ * Create formatted error object
+ * @param {Object} parsedError - Parsed error object
+ * @param {Object} safeError - Safe error object
+ * @param {Error|string|Object} originalError - Original error
+ * @returns {Error} Formatted error object
+ */
+function createFormattedError(parsedError, safeError, originalError) {
   const finalErrorMessage = (parsedError && parsedError.message) ? parsedError.message : (safeError.message || 'Unknown error occurred');
 
-  // Validate finalErrorMessage is a string
   if (typeof finalErrorMessage !== 'string') {
-    throw new Error(`Invalid error message type: ${typeof finalErrorMessage}. Error: ${JSON.stringify(error)}`);
+    throw new Error(`Invalid error message type: ${typeof finalErrorMessage}. Error: ${JSON.stringify(originalError)}`);
   }
 
-  // Throw clean error message (without emoji) - CLI will format it
   const formattedError = new Error(finalErrorMessage);
   formattedError.formatted = parsedError?.formatted || finalErrorMessage;
   formattedError.status = safeError.status;
   formattedError.data = parsedError?.data;
-  formattedError._logged = true; // Mark as logged to prevent double-logging
-  throw formattedError;
+  formattedError._logged = true;
+
+  return formattedError;
+}
+
+/**
+ * Unified error handler for deployment errors
+ * Handles audit logging, error formatting, and user-friendly messages
+ * @param {Error} error - Error object
+ * @param {string} appName - Application name for audit logging
+ * @param {string} url - Controller URL for audit logging
+ * @param {boolean} [alreadyLogged=false] - Whether error has already been logged
+ * @throws {Error} User-friendly error message
+ */
+async function handleDeploymentErrors(error, appName, url, alreadyLogged = false) {
+  // Extract error message
+  const errorMessage = extractErrorMessage(error);
+
+  // For validation errors (like URL validation), just re-throw them directly
+  if (isValidationError(errorMessage)) {
+    throwValidationError(error, errorMessage);
+  }
+
+  // Log to audit log if not already logged
+  if (!alreadyLogged) {
+    await logDeploymentFailure(appName, url, error);
+  }
+
+  const safeError = handleDeploymentError(error);
+  const errorResponse = extractErrorResponse(safeError, error);
+  const parsedError = parseErrorResponseSafely(errorResponse, safeError);
+
+  // Ensure parsedError is always a valid object
+  const validParsedError = (!parsedError || typeof parsedError !== 'object')
+    ? {
+      message: safeError.message || 'Unknown error occurred',
+      formatted: safeError.message || 'Unknown error occurred',
+      data: undefined
+    }
+    : parsedError;
+
+  // Create and throw formatted error
+  throw createFormattedError(validParsedError, safeError, error);
 }
 
 module.exports = {

package/lib/utils/deployment-validation-helpers.js

@@ -0,0 +1,103 @@
+/**
+ * Deployment Validation Helper Functions
+ *
+ * Helper functions for processing deployment validation responses.
+ * Separated from deployer.js to maintain file size limits.
+ *
+ * @fileoverview Deployment validation response processing helpers
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Process successful validation response
+ * @param {Object} responseData - Response data
+ * @returns {Object} Validation result
+ */
+function processSuccessfulValidation(responseData) {
+  return {
+    success: true,
+    validateToken: responseData.validateToken,
+    draftDeploymentId: responseData.draftDeploymentId,
+    imageServer: responseData.imageServer,
+    imageUsername: responseData.imageUsername,
+    imagePassword: responseData.imagePassword,
+    expiresAt: responseData.expiresAt
+  };
+}
+
+/**
+ * Process validation failure response
+ * @param {Object} responseData - Response data
+ * @throws {Error} Validation error
+ */
+function processValidationFailure(responseData) {
+  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;
+}
+
+/**
+ * Process validation error response
+ * @param {Object} response - API response
+ * @throws {Error} Validation error
+ */
+function processValidationError(response) {
+  const error = new Error(`Validation request failed: ${response.formattedError || response.error || 'Unknown error'}`);
+  error.status = response.status || 400;
+  error.data = response.data;
+  throw error;
+}
+
+/**
+ * Process unexpected validation response state
+ * @param {Object} responseData - Response data
+ * @throws {Error} Unexpected state error
+ */
+function processUnexpectedValidationState(responseData) {
+  const error = new Error('Validation response is in an unexpected state');
+  error.status = 400;
+  error.data = responseData;
+  throw error;
+}
+
+/**
+ * Handle validation response
+ * @param {Object} response - API response
+ * @returns {Object|null} Validation result or null if needs retry
+ * @throws {Error} If validation fails
+ */
+function handleValidationResponse(response) {
+  // 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 processSuccessfulValidation(responseData);
+    }
+    // Handle validation failure (valid: false)
+    if (responseData.valid === false) {
+      processValidationFailure(responseData);
+    }
+  }
+
+  // Handle validation errors (non-success responses)
+  if (!response.success) {
+    processValidationError(response);
+  }
+
+  // If we get here, response.success is true but valid is not true and not false
+  processUnexpectedValidationState(response.data);
+}
+
+module.exports = {
+  processSuccessfulValidation,
+  processValidationFailure,
+  processValidationError,
+  processUnexpectedValidationState,
+  handleValidationResponse
+};
+

package/lib/utils/docker-build.js

@@ -190,8 +190,65 @@ async function executeDockerBuild(imageName, dockerfilePath, contextPath, tag) {
   });
 }
 
+/**
+ * Execute Docker build with additional tagging
+ * @async
+ * @param {string} imageName - Image name to build
+ * @param {string} dockerfilePath - Path to Dockerfile
+ * @param {string} contextPath - Build context path
+ * @param {string} tag - Image tag
+ * @param {Object} options - Build options
+ * @returns {Promise<void>} Resolves when build completes
+ * @throws {Error} If build fails
+ */
+async function executeBuild(imageName, dockerfilePath, contextPath, tag, options) {
+  await executeDockerBuild(imageName, dockerfilePath, contextPath, tag);
+
+  // Tag image if additional tag provided
+  if (options && options.tag && options.tag !== 'latest') {
+    const { promisify } = require('util');
+    const { exec } = require('child_process');
+    const run = promisify(exec);
+    await run(`docker tag ${imageName}:${tag} ${imageName}:latest`);
+  }
+}
+
+/**
+ * Execute Docker build and tag with compatibility tag
+ * @async
+ * @param {string} effectiveImageName - Effective image name
+ * @param {string} imageName - Base image name
+ * @param {string} dockerfilePath - Dockerfile path
+ * @param {string} contextPath - Build context path
+ * @param {string} tag - Image tag
+ * @param {Object} options - Build options
+ * @returns {Promise<void>}
+ */
+async function executeDockerBuildWithTag(effectiveImageName, imageName, dockerfilePath, contextPath, tag, options) {
+  const logger = require('../utils/logger');
+  const chalk = require('chalk');
+
+  logger.log(chalk.blue(`Using Dockerfile: ${dockerfilePath}`));
+  logger.log(chalk.blue(`Using build context: ${contextPath}`));
+
+  await executeBuild(effectiveImageName, dockerfilePath, contextPath, tag, options);
+
+  // Back-compat: also tag the built dev image as the base image name
+  try {
+    const { promisify } = require('util');
+    const { exec } = require('child_process');
+    const run = promisify(exec);
+    await run(`docker tag ${effectiveImageName}:${tag} ${imageName}:${tag}`);
+    logger.log(chalk.green(`✓ Tagged image: ${imageName}:${tag}`));
+  } catch (err) {
+    logger.log(chalk.yellow(`⚠️  Warning: Could not create compatibility tag ${imageName}:${tag} - ${err.message}`));
+  }
+}
+
 module.exports = {
   executeDockerBuild,
+  executeBuild,
+  executeDockerBuildWithTag,
   isDockerNotAvailableError
 };
 

package/lib/utils/dockerfile-utils.js

@@ -22,10 +22,19 @@ const handlebars = require('handlebars');
  * @throws {Error} If template not found
  */
 function loadDockerfileTemplate(language) {
-  const templatePath = path.join(__dirname, '..', '..', 'templates', language, 'Dockerfile.hbs');
+  // Use getProjectRoot to reliably find templates in all environments
+  const { getProjectRoot } = require('./paths');
+  const projectRoot = getProjectRoot();
+  const templatePath = path.join(projectRoot, 'templates', language, 'Dockerfile.hbs');
 
   if (!fsSync.existsSync(templatePath)) {
-    throw new Error(`Template not found for language: ${language}`);
+    // Provide helpful error message with actual paths checked
+    const errorMessage = `Template not found for language: ${language}\n` +
+      `  Expected path: ${templatePath}\n` +
+      `  Project root: ${projectRoot}\n` +
+      `  Templates directory: ${path.join(projectRoot, 'templates', language)}\n` +
+      `  Global PROJECT_ROOT: ${typeof global !== 'undefined' && global.PROJECT_ROOT ? global.PROJECT_ROOT : 'not set'}`;
+    throw new Error(errorMessage);
   }
 
   const templateContent = fsSync.readFileSync(templatePath, 'utf8');
@@ -114,7 +123,8 @@ function checkProjectDockerfile(builderPath, appName, buildConfig, contextPath,
     return customPath;
   }
 
-  const builderCustomPath = path.join(process.cwd(), 'builder', appName, customDockerfile);
+  // Use builderPath instead of process.cwd() to handle test scenarios
+  const builderCustomPath = path.join(builderPath, customDockerfile);
   if (fsSync.existsSync(builderCustomPath)) {
     return builderCustomPath;
   }