@aifabrix/builder 2.31.1 → 2.32.2

package/lib/{template-validator.js → validation/template.js}

@@ -11,7 +11,7 @@
 const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
-const { getProjectRoot } = require('./utils/paths');
+const { getProjectRoot } = require('../utils/paths');
 
 /**
  * Validates that a template exists and contains files
@@ -112,17 +112,14 @@ async function copyTemplateFiles(templateName, appPath) {
  * @returns {Promise<string[]>} Array of copied file paths
  * @throws {Error} If language template doesn't exist or copying fails
  */
-async function copyAppFiles(language, appPath) {
-  if (!language || typeof language !== 'string') {
-    throw new Error('Language is required and must be a string');
-  }
-
-  const normalizedLanguage = language.toLowerCase();
-  // Use getProjectRoot to reliably find templates in all environments (including CI)
-  const projectRoot = getProjectRoot();
-  const languageTemplatePath = path.join(projectRoot, 'templates', normalizedLanguage);
-
-  // Check if language template folder exists
+/**
+ * Validates language template path
+ * @function validateLanguageTemplatePath
+ * @param {string} languageTemplatePath - Template path
+ * @param {string} normalizedLanguage - Normalized language name
+ * @throws {Error} If path is invalid
+ */
+function validateLanguageTemplatePath(languageTemplatePath, normalizedLanguage) {
   if (!fsSync.existsSync(languageTemplatePath)) {
     throw new Error(`Language template '${normalizedLanguage}' not found. Expected folder: templates/${normalizedLanguage}/`);
   }
@@ -131,14 +128,17 @@ async function copyAppFiles(language, appPath) {
   if (!stats.isDirectory()) {
     throw new Error(`Language template '${normalizedLanguage}' exists but is not a directory`);
   }
+}
 
-  const copiedFiles = [];
-  const entries = await fs.readdir(languageTemplatePath);
-
-  // Copy only application files, skip Dockerfile and docker-compose templates
-  const appFiles = entries.filter(entry => {
+/**
+ * Filters application files from entries
+ * @function filterAppFiles
+ * @param {string[]} entries - Directory entries
+ * @returns {string[]} Filtered application files
+ */
+function filterAppFiles(entries) {
+  return entries.filter(entry => {
     const lowerEntry = entry.toLowerCase();
-    // Include .gitignore, exclude .hbs files and docker-related files
     if (entry === '.gitignore') {
       return true;
     }
@@ -153,15 +153,46 @@ async function copyAppFiles(language, appPath) {
     }
     return true;
   });
+}
 
+/**
+ * Copies a single file
+ * @async
+ * @function copySingleFile
+ * @param {string} sourcePath - Source file path
+ * @param {string} targetPath - Target file path
+ * @returns {Promise<string|null>} Target path if copied, null otherwise
+ */
+async function copySingleFile(sourcePath, targetPath) {
+  const entryStats = await fs.stat(sourcePath);
+  if (entryStats.isFile()) {
+    await fs.copyFile(sourcePath, targetPath);
+    return targetPath;
+  }
+  return null;
+}
+
+async function copyAppFiles(language, appPath) {
+  if (!language || typeof language !== 'string') {
+    throw new Error('Language is required and must be a string');
+  }
+
+  const normalizedLanguage = language.toLowerCase();
+  const projectRoot = getProjectRoot();
+  const languageTemplatePath = path.join(projectRoot, 'templates', normalizedLanguage);
+
+  validateLanguageTemplatePath(languageTemplatePath, normalizedLanguage);
+
+  const entries = await fs.readdir(languageTemplatePath);
+  const appFiles = filterAppFiles(entries);
+
+  const copiedFiles = [];
   for (const entry of appFiles) {
     const sourcePath = path.join(languageTemplatePath, entry);
     const targetPath = path.join(appPath, entry);
-
-    const entryStats = await fs.stat(sourcePath);
-    if (entryStats.isFile()) {
-      await fs.copyFile(sourcePath, targetPath);
-      copiedFiles.push(targetPath);
+    const copied = await copySingleFile(sourcePath, targetPath);
+    if (copied) {
+      copiedFiles.push(copied);
     }
   }
 

package/lib/{validate.js → validation/validate.js}

@@ -13,11 +13,11 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 const validator = require('./validator');
-const { resolveExternalFiles } = require('./utils/schema-resolver');
-const { loadExternalSystemSchema, loadExternalDataSourceSchema, detectSchemaType } = require('./utils/schema-loader');
-const { formatValidationErrors } = require('./utils/error-formatter');
-const { detectAppType } = require('./utils/paths');
-const logger = require('./utils/logger');
+const { resolveExternalFiles } = require('../utils/schema-resolver');
+const { loadExternalSystemSchema, loadExternalDataSourceSchema, detectSchemaType } = require('../utils/schema-loader');
+const { formatValidationErrors } = require('../utils/error-formatter');
+const { detectAppType } = require('../utils/paths');
+const logger = require('../utils/logger');
 
 /**
  * Validates a file path (detects type and validates)
@@ -49,10 +49,10 @@ async function validateExternalFilesForApp(appName) {
   for (const file of files) {
     const result = await validateExternalFile(file.path, file.type);
     validations.push({
+      ...result,
       file: file.fileName,
       path: file.path,
-      type: file.type,
-      ...result
+      type: file.type
     });
   }
 
@@ -103,54 +103,89 @@ function aggregateValidationResults(appValidation, externalValidations, rbacVali
  * @param {string} type - File type: 'system' | 'datasource'
  * @returns {Promise<Object>} Validation result
  */
-async function validateExternalFile(filePath, type) {
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-
+/**
+ * Parses JSON file content
+ * @function parseJsonFileContent
+ * @param {string} filePath - File path
+ * @returns {Object} Parse result with parsed object or error
+ */
+function parseJsonFileContent(filePath) {
   const content = fs.readFileSync(filePath, 'utf8');
-  let parsed;
-
   try {
-    parsed = JSON.parse(content);
+    return { parsed: JSON.parse(content), error: null };
   } catch (error) {
     return {
-      valid: false,
-      errors: [`Invalid JSON syntax: ${error.message}`],
-      warnings: []
+      parsed: null,
+      error: {
+        valid: false,
+        errors: [`Invalid JSON syntax: ${error.message}`],
+        warnings: []
+      }
     };
   }
+}
 
-  let validate;
-  // Normalize type: handle both 'external-system'/'external-datasource' and 'system'/'datasource'
-  const normalizedType = type === 'external-system' ? 'system' : (type === 'external-datasource' ? 'datasource' : type);
+/**
+ * Gets validator function for file type
+ * @function getValidatorForType
+ * @param {string} normalizedType - Normalized file type
+ * @returns {Function} Validator function
+ * @throws {Error} If type is unknown
+ */
+function getValidatorForType(normalizedType) {
   if (normalizedType === 'system') {
-    validate = loadExternalSystemSchema();
-  } else if (normalizedType === 'datasource') {
-    validate = loadExternalDataSourceSchema();
-  } else {
-    throw new Error(`Unknown file type: ${type}`);
+    return loadExternalSystemSchema();
+  }
+  if (normalizedType === 'datasource') {
+    return loadExternalDataSourceSchema();
   }
+  throw new Error(`Unknown file type: ${normalizedType}`);
+}
 
-  const valid = validate(parsed);
+/**
+ * Validates role references in permissions
+ * @function validateRoleReferences
+ * @param {Object} parsed - Parsed JSON object
+ * @param {string[]} errors - Errors array to append to
+ */
+function validateRoleReferences(parsed, errors) {
+  if (!parsed.permissions || !Array.isArray(parsed.permissions)) {
+    return;
+  }
+
+  const roles = parsed.roles || [];
+  const roleValues = new Set(roles.map(r => r.value));
+
+  parsed.permissions.forEach((permission, index) => {
+    if (permission.roles && Array.isArray(permission.roles)) {
+      permission.roles.forEach(roleValue => {
+        if (!roleValues.has(roleValue)) {
+          errors.push(`Permission "${permission.name}" (index ${index}) references role "${roleValue}" which does not exist in roles array`);
+        }
+      });
+    }
+  });
+}
+
+async function validateExternalFile(filePath, type) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const parseResult = parseJsonFileContent(filePath);
+  if (parseResult.error) {
+    return parseResult.error;
+  }
+
+  const normalizedType = type === 'external-system' ? 'system' : (type === 'external-datasource' ? 'datasource' : type);
+  const validate = getValidatorForType(normalizedType);
+  const valid = validate(parseResult.parsed);
 
   const errors = valid ? [] : formatValidationErrors(validate.errors);
   const warnings = [];
 
-  // Additional validation for external system files: check role references in permissions
-  if (normalizedType === 'system' && parsed.permissions && Array.isArray(parsed.permissions)) {
-    const roles = parsed.roles || [];
-    const roleValues = new Set(roles.map(r => r.value));
-
-    parsed.permissions.forEach((permission, index) => {
-      if (permission.roles && Array.isArray(permission.roles)) {
-        permission.roles.forEach(roleValue => {
-          if (!roleValues.has(roleValue)) {
-            errors.push(`Permission "${permission.name}" (index ${index}) references role "${roleValue}" which does not exist in roles array`);
-          }
-        });
-      }
-    });
+  if (normalizedType === 'system') {
+    validateRoleReferences(parseResult.parsed, errors);
   }
 
   return {
@@ -176,43 +211,38 @@ async function validateExternalFile(filePath, type) {
  * const result = await validateAppOrFile('myapp');
  * // Returns: { valid: true, application: {...}, externalFiles: [...] }
  */
-async function validateAppOrFile(appOrFile) {
-  if (!appOrFile || typeof appOrFile !== 'string') {
-    throw new Error('App name or file path is required');
-  }
-
-  // Check if it's a file path (exists and is a file)
-  const isFilePath = fs.existsSync(appOrFile) && fs.statSync(appOrFile).isFile();
-
-  if (isFilePath) {
-    return await validateFilePath(appOrFile);
+/**
+ * Validates RBAC for external systems
+ * @async
+ * @function validateRbacForExternalSystem
+ * @param {boolean} isExternal - Whether app is external system
+ * @param {string} appName - Application name
+ * @returns {Promise<Object|null>} RBAC validation result or null
+ */
+async function validateRbacForExternalSystem(isExternal, appName) {
+  if (!isExternal) {
+    return null;
   }
 
-  // Treat as app name
-  const appName = appOrFile;
-
-  // Detect app type to support both builder/ and integration/ directories
-  const { appPath, isExternal } = await detectAppType(appName);
-
-  // Validate application
-  const appValidation = await validator.validateApplication(appName);
-
-  // Validate rbac.yaml for external systems
-  let rbacValidation = null;
-  if (isExternal) {
-    try {
-      rbacValidation = await validator.validateRbac(appName);
-    } catch (error) {
-      rbacValidation = {
-        valid: false,
-        errors: [error.message],
-        warnings: []
-      };
-    }
+  try {
+    return await validator.validateRbac(appName);
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [error.message],
+      warnings: []
+    };
   }
+}
 
-  // Check for externalIntegration block
-  const variablesPath = path.join(appPath, 'variables.yaml');
+/**
+ * Loads and checks variables.yaml for externalIntegration
+ * @function loadVariablesAndCheckExternalIntegration
+ * @param {string} variablesPath - Path to variables.yaml
+ * @param {Object} appValidation - Application validation result
+ * @returns {Object|null} Variables object or null if no externalIntegration
+ */
+function loadVariablesAndCheckExternalIntegration(variablesPath, appValidation) {
   if (!fs.existsSync(variablesPath)) {
     return {
       valid: appValidation.valid,
@@ -236,7 +266,6 @@ async function validateAppOrFile(appOrFile) {
     };
   }
 
-  // If no externalIntegration block, return app validation only
   if (!variables.externalIntegration) {
     return {
       valid: appValidation.valid,
@@ -245,10 +274,31 @@ async function validateAppOrFile(appOrFile) {
     };
   }
 
-  // Validate external files
-  const externalValidations = await validateExternalFilesForApp(appName);
+  return null;
+}
+
+async function validateAppOrFile(appOrFile) {
+  if (!appOrFile || typeof appOrFile !== 'string') {
+    throw new Error('App name or file path is required');
+  }
+
+  const isFilePath = fs.existsSync(appOrFile) && fs.statSync(appOrFile).isFile();
+  if (isFilePath) {
+    return await validateFilePath(appOrFile);
+  }
+
+  const appName = appOrFile;
+  const { appPath, isExternal } = await detectAppType(appName);
+  const appValidation = await validator.validateApplication(appName);
+  const rbacValidation = await validateRbacForExternalSystem(isExternal, appName);
+
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  const earlyReturn = loadVariablesAndCheckExternalIntegration(variablesPath, appValidation);
+  if (earlyReturn) {
+    return earlyReturn;
+  }
 
-  // Aggregate results
+  const externalValidations = await validateExternalFilesForApp(appName);
   return aggregateValidationResults(appValidation, externalValidations, rbacValidation);
 }
 
@@ -258,69 +308,97 @@ async function validateAppOrFile(appOrFile) {
  * @function displayValidationResults
  * @param {Object} result - Validation result from validateAppOrFile
  */
-function displayValidationResults(result) {
-  if (result.valid) {
-    logger.log(chalk.green('\n✓ Validation passed!'));
+/**
+ * Displays application validation results
+ * @function displayApplicationValidation
+ * @param {Object} application - Application validation result
+ */
+function displayApplicationValidation(application) {
+  if (!application) {
+    return;
+  }
+
+  logger.log(chalk.blue('\nApplication:'));
+  if (application.valid) {
+    logger.log(chalk.green('  ✓ Application configuration is valid'));
   } else {
-    logger.log(chalk.red('\n✗ Validation failed!'));
+    logger.log(chalk.red('  ✗ Application configuration has errors:'));
+    application.errors.forEach(error => {
+      logger.log(chalk.red(`    • ${error}`));
+    });
+  }
+  if (application.warnings && application.warnings.length > 0) {
+    application.warnings.forEach(warning => {
+      logger.log(chalk.yellow(`    ⚠ ${warning}`));
+    });
+  }
+}
+
+/**
+ * Displays external files validation results
+ * @function displayExternalFilesValidation
+ * @param {Array} externalFiles - External files validation results
+ */
+function displayExternalFilesValidation(externalFiles) {
+  if (!externalFiles || externalFiles.length === 0) {
+    return;
   }
 
-  // Display application validation
-  if (result.application) {
-    logger.log(chalk.blue('\nApplication:'));
-    if (result.application.valid) {
-      logger.log(chalk.green('  ✓ Application configuration is valid'));
+  logger.log(chalk.blue('\nExternal Integration Files:'));
+  externalFiles.forEach(file => {
+    if (file.valid) {
+      logger.log(chalk.green(`  ✓ ${file.file} (${file.type})`));
     } else {
-      logger.log(chalk.red('  ✗ Application configuration has errors:'));
-      result.application.errors.forEach(error => {
+      logger.log(chalk.red(`  ✗ ${file.file} (${file.type}):`));
+      file.errors.forEach(error => {
         logger.log(chalk.red(`    • ${error}`));
       });
     }
-    if (result.application.warnings && result.application.warnings.length > 0) {
-      result.application.warnings.forEach(warning => {
+    if (file.warnings && file.warnings.length > 0) {
+      file.warnings.forEach(warning => {
         logger.log(chalk.yellow(`    ⚠ ${warning}`));
       });
     }
+  });
+}
+
+/**
+ * Displays RBAC validation results
+ * @function displayRbacValidation
+ * @param {Object} rbac - RBAC validation result
+ */
+function displayRbacValidation(rbac) {
+  if (!rbac) {
+    return;
   }
 
-  // Display external files validation
-  if (result.externalFiles && result.externalFiles.length > 0) {
-    logger.log(chalk.blue('\nExternal Integration Files:'));
-    result.externalFiles.forEach(file => {
-      if (file.valid) {
-        logger.log(chalk.green(`  ✓ ${file.file} (${file.type})`));
-      } else {
-        logger.log(chalk.red(`  ✗ ${file.file} (${file.type}):`));
-        file.errors.forEach(error => {
-          logger.log(chalk.red(`    • ${error}`));
-        });
-      }
-      if (file.warnings && file.warnings.length > 0) {
-        file.warnings.forEach(warning => {
-          logger.log(chalk.yellow(`    ⚠ ${warning}`));
-        });
-      }
+  logger.log(chalk.blue('\nRBAC Configuration:'));
+  if (rbac.valid) {
+    logger.log(chalk.green('  ✓ RBAC configuration is valid'));
+  } else {
+    logger.log(chalk.red('  ✗ RBAC configuration has errors:'));
+    rbac.errors.forEach(error => {
+      logger.log(chalk.red(`    • ${error}`));
     });
   }
+  if (rbac.warnings && rbac.warnings.length > 0) {
+    rbac.warnings.forEach(warning => {
+      logger.log(chalk.yellow(`    ⚠ ${warning}`));
+    });
+  }
+}
 
-  // Display rbac validation (for external systems)
-  if (result.rbac) {
-    logger.log(chalk.blue('\nRBAC Configuration:'));
-    if (result.rbac.valid) {
-      logger.log(chalk.green('  ✓ RBAC configuration is valid'));
-    } else {
-      logger.log(chalk.red('  ✗ RBAC configuration has errors:'));
-      result.rbac.errors.forEach(error => {
-        logger.log(chalk.red(`    • ${error}`));
-      });
-    }
-    if (result.rbac.warnings && result.rbac.warnings.length > 0) {
-      result.rbac.warnings.forEach(warning => {
-        logger.log(chalk.yellow(`    ⚠ ${warning}`));
-      });
-    }
+function displayValidationResults(result) {
+  if (result.valid) {
+    logger.log(chalk.green('\n✓ Validation passed!'));
+  } else {
+    logger.log(chalk.red('\n✗ Validation failed!'));
   }
 
+  displayApplicationValidation(result.application);
+  displayExternalFilesValidation(result.externalFiles);
+  displayRbacValidation(result.rbac);
+
   // Display file validation (for direct file validation)
   if (result.file) {
     logger.log(chalk.blue(`\nFile: ${result.file}`));
@@ -352,6 +430,8 @@ function displayValidationResults(result) {
 module.exports = {
   validateAppOrFile,
   displayValidationResults,
-  validateExternalFile
+  validateExternalFile,
+  validateExternalFilesForApp,
+  validateFilePath
 };
 

package/lib/{validator.js → validation/validator.js}

@@ -13,13 +13,13 @@ const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const Ajv = require('ajv');
-const applicationSchema = require('./schema/application-schema.json');
-const externalSystemSchema = require('./schema/external-system.schema.json');
-const externalDataSourceSchema = require('./schema/external-datasource.schema.json');
-const { transformVariablesForValidation } = require('./utils/variable-transformer');
-const { checkEnvironment } = require('./utils/environment-checker');
-const { formatValidationErrors } = require('./utils/error-formatter');
-const { detectAppType } = require('./utils/paths');
+const applicationSchema = require('../schema/application-schema.json');
+const externalSystemSchema = require('../schema/external-system.schema.json');
+const externalDataSourceSchema = require('../schema/external-datasource.schema.json');
+const { transformVariablesForValidation } = require('../utils/variable-transformer');
+const { checkEnvironment } = require('../utils/environment-checker');
+const { formatValidationErrors } = require('../utils/error-formatter');
+const { detectAppType } = require('../utils/paths');
 
 /**
  * Validates variables.yaml file against application schema
@@ -35,12 +35,15 @@ const { detectAppType } = require('./utils/paths');
  * const result = await validateVariables('myapp');
  * // Returns: { valid: true, errors: [], warnings: [] }
  */
-async function validateVariables(appName) {
-  if (!appName || typeof appName !== 'string') {
-    throw new Error('App name is required and must be a string');
-  }
-
-  // Detect app type and get correct path (integration or builder)
+/**
+ * Loads and parses variables.yaml
+ * @async
+ * @function loadVariablesYaml
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Variables object
+ * @throws {Error} If file not found or invalid
+ */
+async function loadVariablesYaml(appName) {
   const { appPath } = await detectAppType(appName);
   const variablesPath = path.join(appPath, 'variables.yaml');
 
@@ -49,51 +52,67 @@ async function validateVariables(appName) {
   }
 
   const content = fs.readFileSync(variablesPath, 'utf8');
-  let variables;
-
   try {
-    variables = yaml.load(content);
+    return yaml.load(content);
   } catch (error) {
     throw new Error(`Invalid YAML syntax in variables.yaml: ${error.message}`);
   }
+}
 
-  // Transform nested structure to flat schema format
-  const transformed = transformVariablesForValidation(variables, appName);
-
+/**
+ * Sets up AJV validator with external schemas
+ * @function setupAjvValidator
+ * @returns {Function} Compiled validator function
+ */
+function setupAjvValidator() {
   const ajv = new Ajv({ allErrors: true, strict: false });
-  // Register external schemas with their $id (GitHub raw URLs)
-  // Create copies to avoid modifying the original schemas
   const externalSystemSchemaCopy = { ...externalSystemSchema };
   const externalDataSourceSchemaCopy = { ...externalDataSourceSchema };
-  // Remove $schema for draft-2020-12 to avoid AJV issues
+
   if (externalDataSourceSchemaCopy.$schema && externalDataSourceSchemaCopy.$schema.includes('2020-12')) {
     delete externalDataSourceSchemaCopy.$schema;
   }
+
   ajv.addSchema(externalSystemSchemaCopy, externalSystemSchema.$id);
   ajv.addSchema(externalDataSourceSchemaCopy, externalDataSourceSchema.$id);
-  const validate = ajv.compile(applicationSchema);
+  return ajv.compile(applicationSchema);
+}
+
+/**
+ * Validates external integration block
+ * @function validateExternalIntegrationBlock
+ * @param {Object} variables - Variables object
+ * @param {string[]} errors - Errors array to append to
+ */
+function validateExternalIntegrationBlock(variables, errors) {
+  if (!variables.externalIntegration) {
+    errors.push('externalIntegration block is required when app.type is "external"');
+    return;
+  }
+
+  if (!variables.externalIntegration.schemaBasePath) {
+    errors.push('externalIntegration.schemaBasePath is required');
+  }
+  if (!variables.externalIntegration.systems || !Array.isArray(variables.externalIntegration.systems) || variables.externalIntegration.systems.length === 0) {
+    errors.push('externalIntegration.systems must be a non-empty array');
+  }
+}
+
+async function validateVariables(appName) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('App name is required and must be a string');
+  }
+
+  const variables = await loadVariablesYaml(appName);
+  const transformed = transformVariablesForValidation(variables, appName);
+  const validate = setupAjvValidator();
   const valid = validate(transformed);
 
-  // Additional explicit validation for external type
   const errors = valid ? [] : formatValidationErrors(validate.errors);
   const warnings = [];
 
-  // If type is external, perform additional checks
   if (variables.app && variables.app.type === 'external') {
-    // Check for externalIntegration block
-    if (!variables.externalIntegration) {
-      errors.push('externalIntegration block is required when app.type is "external"');
-    } else {
-      // Validate externalIntegration structure
-      if (!variables.externalIntegration.schemaBasePath) {
-        errors.push('externalIntegration.schemaBasePath is required');
-      }
-      if (!variables.externalIntegration.systems || !Array.isArray(variables.externalIntegration.systems) || variables.externalIntegration.systems.length === 0) {
-        errors.push('externalIntegration.systems must be a non-empty array');
-      }
-      // Note: dataSources can be empty, so we don't validate that here
-      // File existence is validated during build/deploy, not during schema validation
-    }
+    validateExternalIntegrationBlock(variables, errors);
   }
 
   return {