@aifabrix/builder 2.4.0 → 2.5.0

package/lib/utils/api-error-handler.js

@@ -11,7 +11,49 @@
  */
 
 const chalk = require('chalk');
-
+/**
+ * Extracts missing permissions from error data
+ * @param {Object} errorData - Error response data
+ * @returns {Array<string>} Array of missing permissions
+ */
+function extractMissingPermissions(errorData) {
+  if (errorData.missingPermissions && Array.isArray(errorData.missingPermissions)) {
+    return errorData.missingPermissions;
+  }
+  if (errorData.missing && errorData.missing.permissions && Array.isArray(errorData.missing.permissions)) {
+    return errorData.missing.permissions;
+  }
+  return [];
+}
+/**
+ * Extracts required permissions from error data
+ * @param {Object} errorData - Error response data
+ * @returns {Array<string>} Array of required permissions
+ */
+function extractRequiredPermissions(errorData) {
+  if (errorData.requiredPermissions && Array.isArray(errorData.requiredPermissions)) {
+    return errorData.requiredPermissions;
+  }
+  if (errorData.required && errorData.required.permissions && Array.isArray(errorData.required.permissions)) {
+    return errorData.required.permissions;
+  }
+  return [];
+}
+/**
+ * Adds permission list to lines array
+ * @param {Array<string>} lines - Lines array to append to
+ * @param {Array<string>} perms - Permissions array
+ * @param {string} label - Label for the permissions list
+ */
+function addPermissionList(lines, perms, label) {
+  if (perms.length > 0) {
+    lines.push(chalk.yellow(`${label}:`));
+    perms.forEach(perm => {
+      lines.push(chalk.gray(`  - ${perm}`));
+    });
+    lines.push('');
+  }
+}
 /**
  * Formats permission error with missing and required permissions
  * @param {Object} errorData - Error response data
@@ -21,45 +63,17 @@ function formatPermissionError(errorData) {
   const lines = [];
   lines.push(chalk.red('❌ Permission Denied\n'));
 
-  // Handle detail message if present
   if (errorData.detail) {
     lines.push(chalk.yellow(errorData.detail));
     lines.push('');
   }
 
-  // Extract missing permissions (support both flat and nested structures)
-  let missingPerms = [];
-  if (errorData.missingPermissions && Array.isArray(errorData.missingPermissions)) {
-    missingPerms = errorData.missingPermissions;
-  } else if (errorData.missing && errorData.missing.permissions && Array.isArray(errorData.missing.permissions)) {
-    missingPerms = errorData.missing.permissions;
-  }
-
-  if (missingPerms.length > 0) {
-    lines.push(chalk.yellow('Missing permissions:'));
-    missingPerms.forEach(perm => {
-      lines.push(chalk.gray(`  - ${perm}`));
-    });
-    lines.push('');
-  }
-
-  // Extract required permissions (support both flat and nested structures)
-  let requiredPerms = [];
-  if (errorData.requiredPermissions && Array.isArray(errorData.requiredPermissions)) {
-    requiredPerms = errorData.requiredPermissions;
-  } else if (errorData.required && errorData.required.permissions && Array.isArray(errorData.required.permissions)) {
-    requiredPerms = errorData.required.permissions;
-  }
+  const missingPerms = extractMissingPermissions(errorData);
+  addPermissionList(lines, missingPerms, 'Missing permissions');
 
-  if (requiredPerms.length > 0) {
-    lines.push(chalk.yellow('Required permissions:'));
-    requiredPerms.forEach(perm => {
-      lines.push(chalk.gray(`  - ${perm}`));
-    });
-    lines.push('');
-  }
+  const requiredPerms = extractRequiredPermissions(errorData);
+  addPermissionList(lines, requiredPerms, 'Required permissions');
 
-  // Use instance (from RFC 7807) or url field
   const requestUrl = errorData.instance || errorData.url;
   const method = errorData.method || 'POST';
   if (requestUrl) {
@@ -72,7 +86,6 @@ function formatPermissionError(errorData) {
 
   return lines.join('\n');
 }
-
 /**
  * Formats validation error with field-level details
  * Handles unified error API response format (RFC 7807 Problem Details)
@@ -124,7 +137,6 @@ function formatValidationError(errorData) {
 
   return lines.join('\n');
 }
-
 /**
  * Formats authentication error
  * @param {Object} errorData - Error response data
@@ -148,7 +160,6 @@ function formatAuthenticationError(errorData) {
 
   return lines.join('\n');
 }
-
 /**
  * Formats network error
  * @param {string} errorMessage - Error message
@@ -241,6 +252,34 @@ function formatConflictError(errorData) {
   return lines.join('\n');
 }
 
+/**
+ * Gets actionable guidance options based on error detail
+ * @param {string} detail - Error detail message
+ * @returns {Array<string>} Array of guidance options
+ */
+function getNotFoundGuidance(detail) {
+  const lowerDetail = detail.toLowerCase();
+  if (lowerDetail.includes('environment')) {
+    return [
+      '  • Check the environment key spelling',
+      '  • List available environments: aifabrix app list -e <environment>',
+      '  • Verify you have access to this environment'
+    ];
+  }
+  if (lowerDetail.includes('application')) {
+    return [
+      '  • Check the application key spelling',
+      '  • List applications: aifabrix app list -e <environment>',
+      '  • Verify the application exists in this environment'
+    ];
+  }
+  return [
+    '  • Check the resource identifier',
+    '  • Verify the resource exists',
+    '  • Check your permissions'
+  ];
+}
+
 /**
  * Formats not found error (404)
  * @param {Object} errorData - Error response data
@@ -250,31 +289,17 @@ function formatNotFoundError(errorData) {
   const lines = [];
   lines.push(chalk.red('❌ Not Found\n'));
 
-  // Extract detail from RFC 7807 Problem Details format
   const detail = errorData.detail || errorData.message || '';
-
   if (detail) {
     lines.push(chalk.yellow(detail));
     lines.push('');
   }
 
-  // Provide actionable guidance based on error context
-  if (detail.toLowerCase().includes('environment')) {
-    lines.push(chalk.gray('Options:'));
-    lines.push(chalk.gray('  • Check the environment key spelling'));
-    lines.push(chalk.gray('  • List available environments: aifabrix app list -e <environment>'));
-    lines.push(chalk.gray('  • Verify you have access to this environment'));
-  } else if (detail.toLowerCase().includes('application')) {
-    lines.push(chalk.gray('Options:'));
-    lines.push(chalk.gray('  • Check the application key spelling'));
-    lines.push(chalk.gray('  • List applications: aifabrix app list -e <environment>'));
-    lines.push(chalk.gray('  • Verify the application exists in this environment'));
-  } else {
-    lines.push(chalk.gray('Options:'));
-    lines.push(chalk.gray('  • Check the resource identifier'));
-    lines.push(chalk.gray('  • Verify the resource exists'));
-    lines.push(chalk.gray('  • Check your permissions'));
-  }
+  lines.push(chalk.gray('Options:'));
+  const guidance = getNotFoundGuidance(detail);
+  guidance.forEach(option => {
+    lines.push(chalk.gray(option));
+  });
 
   if (errorData.correlationId) {
     lines.push('');
@@ -314,31 +339,109 @@ function formatGenericError(errorData, statusCode) {
 }
 
 /**
- * Parses error response and determines error type
+ * Parses error response into error data object
  * @param {string|Object} errorResponse - Error response (string or parsed JSON)
- * @param {number} statusCode - HTTP status code
- * @param {boolean} isNetworkError - Whether this is a network error
- * @returns {Object} Parsed error object with type, message, and formatted output
+ * @returns {Object} Parsed error data object
  */
-function parseErrorResponse(errorResponse, statusCode, isNetworkError) {
-  let errorData = {};
-
-  // Handle undefined or null error response
+function parseErrorData(errorResponse) {
   if (errorResponse === undefined || errorResponse === null) {
-    errorData = { message: 'Unknown error occurred' };
-  } else if (typeof errorResponse === 'string') {
-    // Parse error response
+    return { message: 'Unknown error occurred' };
+  }
+  if (typeof errorResponse === 'string') {
     try {
-      errorData = JSON.parse(errorResponse);
+      return JSON.parse(errorResponse);
     } catch {
-      errorData = { message: errorResponse };
+      return { message: errorResponse };
     }
-  } else if (typeof errorResponse === 'object') {
-    errorData = errorResponse;
-  } else {
-    // Fallback for unexpected types
-    errorData = { message: String(errorResponse) };
   }
+  if (typeof errorResponse === 'object') {
+    return errorResponse;
+  }
+  return { message: String(errorResponse) };
+}
+
+/**
+ * Creates error result object
+ * @param {string} type - Error type
+ * @param {string} message - Error message
+ * @param {string} formatted - Formatted error message
+ * @param {Object} data - Error data
+ * @returns {Object} Error result object
+ */
+function createErrorResult(type, message, formatted, data) {
+  return { type, message, formatted, data };
+}
+
+/**
+ * Gets error message from error data
+ * @param {Object} errorData - Error data object
+ * @param {string} defaultMessage - Default message if not found
+ * @returns {string} Error message
+ */
+function getErrorMessage(errorData, defaultMessage) {
+  return errorData.detail || errorData.title || errorData.message || defaultMessage;
+}
+
+/**
+ * Handles 400 validation error
+ * @param {Object} errorData - Error data object
+ * @returns {Object} Error result object
+ */
+function handleValidationError(errorData) {
+  const errorMessage = getErrorMessage(errorData, 'Validation error');
+  return createErrorResult('validation', errorMessage, formatValidationError(errorData), errorData);
+}
+
+/**
+ * Handles specific 4xx client error codes
+ * @param {number} statusCode - HTTP status code
+ * @param {Object} errorData - Error data object
+ * @returns {Object|null} Error result object or null if not handled
+ */
+function handleSpecificClientErrors(statusCode, errorData) {
+  switch (statusCode) {
+  case 403:
+    return createErrorResult('permission', 'Permission denied', formatPermissionError(errorData), errorData);
+  case 401:
+    return createErrorResult('authentication', 'Authentication failed', formatAuthenticationError(errorData), errorData);
+  case 400:
+    return handleValidationError(errorData);
+  case 404:
+    return createErrorResult('notfound', getErrorMessage(errorData, 'Not found'), formatNotFoundError(errorData), errorData);
+  case 409:
+    return createErrorResult('conflict', getErrorMessage(errorData, 'Conflict'), formatConflictError(errorData), errorData);
+  default:
+    return null;
+  }
+}
+
+/**
+ * Handles HTTP status code errors
+ * @param {number} statusCode - HTTP status code
+ * @param {Object} errorData - Error data object
+ * @returns {Object|null} Error result object or null if not handled
+ */
+function handleStatusCodeError(statusCode, errorData) {
+  // Handle 4xx client errors
+  if (statusCode >= 400 && statusCode < 500) {
+    return handleSpecificClientErrors(statusCode, errorData);
+  }
+  // Handle 5xx server errors
+  if (statusCode >= 500) {
+    return createErrorResult('server', 'Server error', formatServerError(errorData), errorData);
+  }
+  return null;
+}
+
+/**
+ * Parses error response and determines error type
+ * @param {string|Object} errorResponse - Error response (string or parsed JSON)
+ * @param {number} statusCode - HTTP status code
+ * @param {boolean} isNetworkError - Whether this is a network error
+ * @returns {Object} Parsed error object with type, message, and formatted output
+ */
+function parseErrorResponse(errorResponse, statusCode, isNetworkError) {
+  let errorData = parseErrorData(errorResponse);
 
   // Handle nested response structure (some APIs wrap errors in data field)
   if (errorData.data && typeof errorData.data === 'object') {
@@ -348,84 +451,17 @@ function parseErrorResponse(errorResponse, statusCode, isNetworkError) {
   // Handle network errors
   if (isNetworkError) {
     const errorMessage = errorData.message || errorResponse || 'Network error';
-    return {
-      type: 'network',
-      message: errorMessage,
-      formatted: formatNetworkError(errorMessage, errorData),
-      data: errorData
-    };
-  }
-
-  // Handle different HTTP status codes
-  if (statusCode === 403) {
-    // Permission error
-    return {
-      type: 'permission',
-      message: 'Permission denied',
-      formatted: formatPermissionError(errorData),
-      data: errorData
-    };
-  }
-
-  if (statusCode === 401) {
-    // Authentication error
-    return {
-      type: 'authentication',
-      message: 'Authentication failed',
-      formatted: formatAuthenticationError(errorData),
-      data: errorData
-    };
-  }
-
-  if (statusCode === 400) {
-    // Validation error
-    // Extract message from unified error format (RFC 7807)
-    const errorMessage = errorData.detail || errorData.title || errorData.message || 'Validation error';
-    return {
-      type: 'validation',
-      message: errorMessage,
-      formatted: formatValidationError(errorData),
-      data: errorData
-    };
-  }
-
-  if (statusCode === 404) {
-    // Not found error
-    return {
-      type: 'notfound',
-      message: errorData.detail || errorData.message || 'Not found',
-      formatted: formatNotFoundError(errorData),
-      data: errorData
-    };
-  }
-
-  if (statusCode === 409) {
-    // Conflict error
-    return {
-      type: 'conflict',
-      message: errorData.detail || errorData.message || 'Conflict',
-      formatted: formatConflictError(errorData),
-      data: errorData
-    };
+    return createErrorResult('network', errorMessage, formatNetworkError(errorMessage, errorData), errorData);
   }
 
-  if (statusCode >= 500) {
-    // Server error
-    return {
-      type: 'server',
-      message: 'Server error',
-      formatted: formatServerError(errorData),
-      data: errorData
-    };
+  // Handle HTTP status codes
+  const statusError = handleStatusCodeError(statusCode, errorData);
+  if (statusError) {
+    return statusError;
   }
 
   // Generic error
-  return {
-    type: 'generic',
-    message: errorData.message || errorData.error || 'Unknown error',
-    formatted: formatGenericError(errorData, statusCode),
-    data: errorData
-  };
+  return createErrorResult('generic', errorData.message || errorData.error || 'Unknown error', formatGenericError(errorData, statusCode), errorData);
 }
 
 /**
@@ -462,4 +498,3 @@ module.exports = {
   formatServerError,
   formatGenericError
 };
-