@aifabrix/builder 2.0.0 → 2.0.2

package/lib/utils/error-formatter.js

@@ -0,0 +1,61 @@
+/**
+ * Error Formatting Utilities
+ *
+ * Formats validation errors into developer-friendly messages
+ * Converts technical schema errors into actionable advice
+ *
+ * @fileoverview Error formatting utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Formats a single validation error into a developer-friendly message
+ *
+ * @function formatSingleError
+ * @param {Object} error - Raw validation error from Ajv
+ * @returns {string} Formatted error message
+ */
+function formatSingleError(error) {
+  const path = error.instancePath ? error.instancePath.slice(1) : 'root';
+  const field = path ? `Field "${path}"` : 'Configuration';
+
+  const errorMessages = {
+    required: `${field}: Missing required property "${error.params.missingProperty}"`,
+    type: `${field}: Expected ${error.params.type}, got ${typeof error.data}`,
+    minimum: `${field}: Value must be at least ${error.params.limit}`,
+    maximum: `${field}: Value must be at most ${error.params.limit}`,
+    minLength: `${field}: Must be at least ${error.params.limit} characters`,
+    maxLength: `${field}: Must be at most ${error.params.limit} characters`,
+    pattern: `${field}: Invalid format`,
+    enum: `${field}: Must be one of: ${error.params.allowedValues?.join(', ') || 'unknown'}`
+  };
+
+  return errorMessages[error.keyword] || `${field}: ${error.message}`;
+}
+
+/**
+ * Formats validation errors into developer-friendly messages
+ * Converts technical schema errors into actionable advice
+ *
+ * @function formatValidationErrors
+ * @param {Array} errors - Raw validation errors from Ajv
+ * @returns {Array} Formatted error messages
+ *
+ * @example
+ * const messages = formatValidationErrors(ajvErrors);
+ * // Returns: ['Port must be between 1 and 65535', 'Missing required field: displayName']
+ */
+function formatValidationErrors(errors) {
+  if (!Array.isArray(errors)) {
+    return ['Unknown validation error'];
+  }
+
+  return errors.map(formatSingleError);
+}
+
+module.exports = {
+  formatSingleError,
+  formatValidationErrors
+};
+

package/lib/utils/health-check.js

@@ -0,0 +1,187 @@
+/**
+ * Health Check Utilities
+ *
+ * Handles health check functionality for application containers
+ *
+ * @fileoverview Health check utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const http = require('http');
+const chalk = require('chalk');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const logger = require('./logger');
+
+const execAsync = promisify(exec);
+
+/**
+ * Checks if db-init container exists and waits for it to complete
+ * @async
+ * @function waitForDbInit
+ * @param {string} appName - Application name
+ * @throws {Error} If db-init fails
+ */
+async function waitForDbInit(appName) {
+  const dbInitContainer = `aifabrix-${appName}-db-init`;
+  try {
+    const { stdout } = await execAsync(`docker ps -a --filter "name=${dbInitContainer}" --format "{{.Names}}"`);
+    if (stdout.trim() !== dbInitContainer) {
+      return;
+    }
+
+    const { stdout: status } = await execAsync(`docker inspect --format='{{.State.Status}}' ${dbInitContainer}`);
+    if (status.trim() === 'exited') {
+      const { stdout: exitCode } = await execAsync(`docker inspect --format='{{.State.ExitCode}}' ${dbInitContainer}`);
+      if (exitCode.trim() === '0') {
+        logger.log(chalk.green('✓ Database initialization already completed'));
+      } else {
+        logger.log(chalk.yellow(`⚠ Database initialization exited with code ${exitCode.trim()}`));
+      }
+      return;
+    }
+
+    logger.log(chalk.blue('Waiting for database initialization to complete...'));
+    const maxDbInitAttempts = 30;
+    for (let dbInitAttempts = 0; dbInitAttempts < maxDbInitAttempts; dbInitAttempts++) {
+      const { stdout: currentStatus } = await execAsync(`docker inspect --format='{{.State.Status}}' ${dbInitContainer}`);
+      if (currentStatus.trim() === 'exited') {
+        const { stdout: exitCode } = await execAsync(`docker inspect --format='{{.State.ExitCode}}' ${dbInitContainer}`);
+        if (exitCode.trim() === '0') {
+          logger.log(chalk.green('✓ Database initialization completed'));
+        } else {
+          logger.log(chalk.yellow(`⚠ Database initialization exited with code ${exitCode.trim()}`));
+        }
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  } catch (error) {
+    // db-init container might not exist, which is fine
+  }
+}
+
+/**
+ * Gets container port from Docker inspect
+ * @async
+ * @function getContainerPort
+ * @param {string} appName - Application name
+ * @returns {Promise<number>} Container port
+ */
+async function getContainerPort(appName) {
+  try {
+    const { stdout: portMapping } = await execAsync(`docker inspect --format='{{range .NetworkSettings.Ports}}{{range .}}{{.HostPort}}{{end}}{{end}}' aifabrix-${appName}`);
+    const ports = portMapping.trim().split('\n').filter(p => p);
+    if (ports.length > 0) {
+      return parseInt(ports[0], 10);
+    }
+  } catch (error) {
+    // Fall through to default
+  }
+  return 3000;
+}
+
+/**
+ * Parses health check response
+ * @function parseHealthResponse
+ * @param {string} data - Response data
+ * @param {number} statusCode - HTTP status code
+ * @returns {boolean} True if healthy
+ */
+function parseHealthResponse(data, statusCode) {
+  try {
+    const health = JSON.parse(data);
+    if (health.status === 'UP') {
+      return true;
+    }
+    if (health.status === 'ok') {
+      return health.database === 'connected' || !health.database;
+    }
+    return false;
+  } catch (error) {
+    return statusCode === 200;
+  }
+}
+
+/**
+ * Checks health endpoint
+ * @async
+ * @function checkHealthEndpoint
+ * @param {string} healthCheckUrl - Health check URL
+ * @returns {Promise<boolean>} True if healthy
+ * @throws {Error} If request fails with exception
+ */
+async function checkHealthEndpoint(healthCheckUrl) {
+  return new Promise((resolve, reject) => {
+    try {
+      const req = http.get(healthCheckUrl, { timeout: 5000 }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          resolve(parseHealthResponse(data, res.statusCode));
+        });
+      });
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+    } catch (error) {
+      // Re-throw exceptions (not just network errors)
+      reject(error);
+    }
+  });
+}
+
+/**
+ * Waits for application health check to pass
+ * Checks HTTP endpoint and waits for healthy response
+ *
+ * @async
+ * @function waitForHealthCheck
+ * @param {string} appName - Application name
+ * @param {number} timeout - Timeout in seconds (default: 90)
+ * @param {number} [port] - Application port (auto-detected if not provided)
+ * @param {Object} [config] - Application configuration
+ * @returns {Promise<void>} Resolves when health check passes
+ * @throws {Error} If health check times out
+ */
+async function waitForHealthCheck(appName, timeout = 90, port = null, config = null) {
+  await waitForDbInit(appName);
+
+  if (!port) {
+    port = await getContainerPort(appName);
+  }
+
+  const healthCheckPath = config?.healthCheck?.path || '/health';
+  const healthCheckUrl = `http://localhost:${port}${healthCheckPath}`;
+  const maxAttempts = timeout / 2;
+
+  for (let attempts = 0; attempts < maxAttempts; attempts++) {
+    try {
+      const healthCheckPassed = await checkHealthEndpoint(healthCheckUrl);
+      if (healthCheckPassed) {
+        logger.log(chalk.green('✓ Application is healthy'));
+        return;
+      }
+    } catch (error) {
+      // If exception occurs, continue retrying until timeout
+      // The error will be handled by timeout error below
+    }
+
+    if (attempts < maxAttempts - 1) {
+      logger.log(chalk.yellow(`Waiting for health check... (${attempts + 1}/${maxAttempts}) ${healthCheckUrl}`));
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  }
+
+  throw new Error(`Health check timeout after ${timeout} seconds`);
+}
+
+module.exports = {
+  waitForHealthCheck
+};
+

package/lib/utils/logger.js

@@ -0,0 +1,53 @@
+/**
+ * Logger Utility
+ *
+ * Centralized logging utility that wraps console methods
+ * Allows disabling eslint warnings in one place
+ *
+ * @fileoverview Logger utility for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/* eslint-disable no-console */
+
+/**
+ * Logger utility that wraps console methods
+ * All console statements should use this logger to avoid eslint warnings
+ */
+const logger = {
+  /**
+   * Log informational message
+   * @param {...any} args - Arguments to log
+   */
+  log: (...args) => {
+    console.log(...args);
+  },
+
+  /**
+   * Log error message
+   * @param {...any} args - Arguments to log
+   */
+  error: (...args) => {
+    console.error(...args);
+  },
+
+  /**
+   * Log warning message
+   * @param {...any} args - Arguments to log
+   */
+  warn: (...args) => {
+    console.warn(...args);
+  },
+
+  /**
+   * Log informational message (alias for log)
+   * @param {...any} args - Arguments to log
+   */
+  info: (...args) => {
+    console.log(...args);
+  }
+};
+
+module.exports = logger;
+

package/lib/utils/template-helpers.js

@@ -0,0 +1,223 @@
+/**
+ * Template Helper Utilities
+ *
+ * Handles template variable loading, updating, and merging
+ *
+ * @fileoverview Template helper utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('./logger');
+
+/**
+ * Loads template variables from template's variables.yaml file
+ * @async
+ * @function loadTemplateVariables
+ * @param {string} templateName - Template name
+ * @returns {Promise<Object|null>} Template variables or null if not found
+ */
+async function loadTemplateVariables(templateName) {
+  if (!templateName) {
+    return null;
+  }
+
+  const yaml = require('js-yaml');
+  const templatePath = path.join(__dirname, '..', '..', 'templates', 'applications', templateName);
+  const templateVariablesPath = path.join(templatePath, 'variables.yaml');
+
+  try {
+    const templateContent = await fs.readFile(templateVariablesPath, 'utf8');
+    return yaml.load(templateContent);
+  } catch (error) {
+    // Template variables.yaml not found or invalid, continue without it
+    if (error.code !== 'ENOENT') {
+      logger.warn(chalk.yellow(`⚠️  Warning: Could not load template variables.yaml: ${error.message}`));
+    }
+    return null;
+  }
+}
+
+/**
+ * Updates app key and display name in variables
+ * @function updateAppMetadata
+ * @param {Object} variables - Variables object
+ * @param {string} appName - Application name
+ */
+function updateAppMetadata(variables, appName) {
+  if (variables.app) {
+    variables.app.key = appName;
+  }
+
+  if (variables.app?.displayName && variables.app.displayName.toLowerCase().includes('miso')) {
+    variables.app.displayName = appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+  }
+}
+
+/**
+ * Updates port in variables if provided
+ * @function updatePort
+ * @param {Object} variables - Variables object
+ * @param {Object} options - CLI options
+ * @param {Object} config - Final configuration
+ */
+function updatePort(variables, options, config) {
+  if (options.port && config.port && variables.port !== config.port) {
+    variables.port = config.port;
+  }
+}
+
+/**
+ * Updates build configuration
+ * @function updateBuildConfig
+ * @param {Object} variables - Variables object
+ */
+function updateBuildConfig(variables) {
+  if (variables.build && variables.build.envOutputPath) {
+    variables.build.envOutputPath = null;
+  }
+}
+
+/**
+ * Updates database configuration for --app flag
+ * @function updateDatabaseConfig
+ * @param {Object} variables - Variables object
+ * @param {Object} options - CLI options
+ * @param {string} appName - Application name
+ */
+function updateDatabaseConfig(variables, options, appName) {
+  if (!options.app || !variables.requires) {
+    return;
+  }
+
+  if (variables.requires.databases) {
+    variables.requires.databases = [{ name: appName }];
+  } else if (variables.requires.database && !variables.requires.databases) {
+    variables.requires.databases = [{ name: appName }];
+  }
+}
+
+/**
+ * Updates variables.yaml file after copying from template
+ * Updates app.key, displayName, and port with actual values
+ * @async
+ * @function updateTemplateVariables
+ * @param {string} appPath - Application directory path
+ * @param {string} appName - Application name
+ * @param {Object} options - CLI options
+ * @param {Object} config - Final configuration
+ */
+async function updateTemplateVariables(appPath, appName, options, config) {
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  try {
+    const yaml = require('js-yaml');
+    const variablesContent = await fs.readFile(variablesPath, 'utf8');
+    const variables = yaml.load(variablesContent);
+
+    updateAppMetadata(variables, appName);
+    updatePort(variables, options, config);
+    updateBuildConfig(variables);
+    updateDatabaseConfig(variables, options, appName);
+
+    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }));
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      logger.warn(chalk.yellow(`⚠️  Warning: Could not update variables.yaml: ${error.message}`));
+    }
+  }
+}
+
+/**
+ * Merges port from template variables if not in options
+ * @function mergePort
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergePort(merged, templateVariables) {
+  if (!merged.port && templateVariables.port) {
+    merged.port = templateVariables.port;
+  }
+}
+
+/**
+ * Merges language from template variables if not in options
+ * @function mergeLanguage
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergeLanguage(merged, templateVariables) {
+  if (!merged.language && templateVariables.build?.language) {
+    merged.language = templateVariables.build.language;
+  }
+}
+
+/**
+ * Merges service requirements from template variables if not in options
+ * @function mergeServices
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergeServices(merged, templateVariables) {
+  // Database: use template requires.database if not specified in options
+  if (!Object.prototype.hasOwnProperty.call(merged, 'database') &&
+      templateVariables.requires?.database !== undefined) {
+    merged.database = templateVariables.requires.database;
+  }
+
+  // Redis: use template requires.redis if not specified in options
+  if (!Object.prototype.hasOwnProperty.call(merged, 'redis') &&
+      templateVariables.requires?.redis !== undefined) {
+    merged.redis = templateVariables.requires.redis;
+  }
+
+  // Storage: use template requires.storage if not specified in options
+  if (!Object.prototype.hasOwnProperty.call(merged, 'storage') &&
+      templateVariables.requires?.storage !== undefined) {
+    merged.storage = templateVariables.requires.storage;
+  }
+}
+
+/**
+ * Merges authentication from template variables if not in options
+ * @function mergeAuthentication
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergeAuthentication(merged, templateVariables) {
+  if (!Object.prototype.hasOwnProperty.call(merged, 'authentication') &&
+      templateVariables.authentication !== undefined) {
+    merged.authentication = !!templateVariables.authentication;
+  }
+}
+
+/**
+ * Merges template variables into options
+ * @function mergeTemplateVariables
+ * @param {Object} options - User-provided options
+ * @param {Object} templateVariables - Template variables from variables.yaml
+ * @returns {Object} Merged options object
+ */
+function mergeTemplateVariables(options, templateVariables) {
+  if (!templateVariables) {
+    return options;
+  }
+
+  const merged = { ...options };
+
+  mergePort(merged, templateVariables);
+  mergeLanguage(merged, templateVariables);
+  mergeServices(merged, templateVariables);
+  mergeAuthentication(merged, templateVariables);
+
+  return merged;
+}
+
+module.exports = {
+  loadTemplateVariables,
+  updateTemplateVariables,
+  mergeTemplateVariables
+};
+