@aifabrix/builder 2.32.2 → 2.33.0

package/lib/validation/external-manifest-validator.js

@@ -0,0 +1,202 @@
+/**
+ * External System Manifest Validator
+ *
+ * Validates controller deployment manifest for external systems.
+ * Validates against application-schema.json and component schemas.
+ *
+ * @fileoverview Manifest validation for external systems
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const Ajv = require('ajv');
+const fs = require('fs');
+const path = require('path');
+const { formatValidationErrors } = require('../utils/error-formatter');
+
+/**
+ * Sets up AJV validator with external schemas
+ * @async
+ * @function setupAjvWithSchemas
+ * @returns {Promise<Object>} AJV instance and schemas
+ */
+async function setupAjvWithSchemas() {
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    removeAdditional: false
+  });
+
+  // Load raw schema objects (not compiled validators)
+  const externalSystemSchemaPath = path.join(__dirname, '..', 'schema', 'external-system.schema.json');
+  const externalDatasourceSchemaPath = path.join(__dirname, '..', 'schema', 'external-datasource.schema.json');
+
+  const externalSystemSchema = JSON.parse(fs.readFileSync(externalSystemSchemaPath, 'utf8'));
+  let externalDatasourceSchema = JSON.parse(fs.readFileSync(externalDatasourceSchemaPath, 'utf8'));
+
+  // Remove $schema for draft-2020-12 to avoid AJV issues
+  if (externalDatasourceSchema.$schema && externalDatasourceSchema.$schema.includes('2020-12')) {
+    const schemaCopy = { ...externalDatasourceSchema };
+    delete schemaCopy.$schema;
+    externalDatasourceSchema = schemaCopy;
+  }
+
+  const externalSystemSchemaId = externalSystemSchema.$id || 'https://raw.githubusercontent.com/esystemsdev/aifabrix-builder/refs/heads/main/lib/schema/external-system.schema.json';
+  const externalDatasourceSchemaId = externalDatasourceSchema.$id || 'https://raw.githubusercontent.com/esystemsdev/aifabrix-builder/refs/heads/main/lib/schema/external-datasource.schema.json';
+
+  ajv.addSchema(externalSystemSchema, externalSystemSchemaId);
+  ajv.addSchema(externalDatasourceSchema, externalDatasourceSchemaId);
+
+  return { ajv, externalSystemSchema, externalDatasourceSchema };
+}
+
+/**
+ * Validates manifest structure
+ * @function validateManifestStructure
+ * @param {Object} manifest - Manifest object
+ * @param {Object} ajv - AJV instance
+ * @param {Object} applicationSchema - Application schema
+ * @param {Array} errors - Errors array to append to
+ * @returns {void}
+ */
+function validateManifestStructure(manifest, ajv, applicationSchema, errors) {
+  const validateManifest = ajv.compile(applicationSchema);
+  const manifestValid = validateManifest(manifest);
+
+  if (!manifestValid) {
+    const manifestErrors = formatValidationErrors(validateManifest.errors);
+    errors.push(...manifestErrors.map(err => `Manifest validation: ${err}`));
+  }
+}
+
+/**
+ * Validates inline system
+ * @function validateInlineSystem
+ * @param {Object} manifest - Manifest object
+ * @param {Object} ajv - AJV instance
+ * @param {Object} externalSystemSchema - External system schema
+ * @param {Array} errors - Errors array to append to
+ * @returns {void}
+ */
+function validateInlineSystem(manifest, ajv, externalSystemSchema, errors) {
+  if (manifest.system) {
+    const validateSystem = ajv.compile(externalSystemSchema);
+    const systemValid = validateSystem(manifest.system);
+
+    if (!systemValid) {
+      const systemErrors = formatValidationErrors(validateSystem.errors);
+      errors.push(...systemErrors.map(err => `System validation: ${err}`));
+    }
+  } else if (manifest.type === 'external') {
+    errors.push('System is required for external type applications');
+  }
+}
+
+/**
+ * Validates datasources
+ * @function validateDatasources
+ * @param {Object} manifest - Manifest object
+ * @param {Object} ajv - AJV instance
+ * @param {Object} externalDatasourceSchema - External datasource schema
+ * @param {Array} errors - Errors array to append to
+ * @param {Array} warnings - Warnings array to append to
+ * @returns {void}
+ */
+function validateDatasources(manifest, ajv, externalDatasourceSchema, errors, warnings) {
+  if (manifest.dataSources) {
+    if (!Array.isArray(manifest.dataSources)) {
+      errors.push('dataSources must be an array');
+    } else {
+      const validateDatasource = ajv.compile(externalDatasourceSchema);
+      manifest.dataSources.forEach((datasource, index) => {
+        const datasourceValid = validateDatasource(datasource);
+        if (!datasourceValid) {
+          const datasourceErrors = formatValidationErrors(validateDatasource.errors);
+          errors.push(...datasourceErrors.map(err => `Datasource ${index + 1} (${datasource.key || 'unknown'}): ${err}`));
+        }
+      });
+    }
+  } else if (manifest.type === 'external') {
+    warnings.push('No dataSources specified - external system may not have any datasources');
+  }
+}
+
+/**
+ * Validates conditional requirements
+ * @function validateConditionalRequirements
+ * @param {Object} manifest - Manifest object
+ * @param {Array} errors - Errors array to append to
+ * @param {Array} warnings - Warnings array to append to
+ * @returns {void}
+ */
+function validateConditionalRequirements(manifest, errors, warnings) {
+  if (manifest.type === 'external') {
+    if (!manifest.system) {
+      errors.push('System is required for external type applications');
+    }
+    if (!manifest.dataSources || manifest.dataSources.length === 0) {
+      warnings.push('No dataSources specified for external system');
+    }
+  }
+}
+
+/**
+ * Validates required fields
+ * @function validateRequiredFields
+ * @param {Object} manifest - Manifest object
+ * @param {Array} errors - Errors array to append to
+ * @returns {void}
+ */
+function validateRequiredFields(manifest, errors) {
+  const requiredFields = ['key', 'displayName', 'description', 'type', 'deploymentKey'];
+  requiredFields.forEach(field => {
+    if (!manifest[field]) {
+      errors.push(`Required field "${field}" is missing`);
+    }
+  });
+}
+
+/**
+ * Validates controller deployment manifest for external systems
+ * Validates manifest structure and inline system/dataSources against their schemas
+ *
+ * @async
+ * @function validateControllerManifest
+ * @param {Object} manifest - Controller manifest object
+ * @returns {Promise<Object>} Validation result
+ * @throws {Error} If validation fails critically
+ *
+ * @example
+ * const result = await validateControllerManifest(manifest);
+ * // Returns: { valid: true, errors: [], warnings: [] }
+ */
+async function validateControllerManifest(manifest) {
+  if (!manifest || typeof manifest !== 'object') {
+    return {
+      valid: false,
+      errors: ['Manifest is required and must be an object'],
+      warnings: []
+    };
+  }
+
+  const errors = [];
+  const warnings = [];
+  const applicationSchema = require('../schema/application-schema.json');
+  const { ajv, externalSystemSchema, externalDatasourceSchema } = await setupAjvWithSchemas();
+
+  validateManifestStructure(manifest, ajv, applicationSchema, errors);
+  validateInlineSystem(manifest, ajv, externalSystemSchema, errors);
+  validateDatasources(manifest, ajv, externalDatasourceSchema, errors, warnings);
+  validateConditionalRequirements(manifest, errors, warnings);
+  validateRequiredFields(manifest, errors);
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+module.exports = {
+  validateControllerManifest
+};

package/lib/validation/validate-display.js

@@ -0,0 +1,406 @@
+/**
+ * Validation Display Utilities
+ *
+ * Display functions for validation results output.
+ *
+ * @fileoverview Validation display utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+
+/**
+ * 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('  ✗ Application configuration has errors:'));
+    if (application.errors && application.errors.length > 0) {
+      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}`));
+    });
+  }
+}
+
+/**
+ * Extracts dimensions from a datasource file
+ * @function extractDimensionsFromDatasource
+ * @param {string} filePath - Path to datasource file
+ * @returns {Object} Dimensions info { dimensions: Object, hasDimensions: boolean }
+ */
+function extractDimensionsFromDatasource(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(content);
+
+    // Check fieldMappings.dimensions (primary location)
+    const dimensions = parsed.fieldMappings?.dimensions || {};
+    const abacDimensions = parsed.abac?.dimensions || {};
+
+    // Merge both sources (abac.dimensions can override fieldMappings.dimensions)
+    const allDimensions = { ...dimensions, ...abacDimensions };
+    const dimensionKeys = Object.keys(allDimensions);
+
+    return {
+      dimensions: allDimensions,
+      dimensionKeys,
+      hasDimensions: dimensionKeys.length > 0
+    };
+  } catch {
+    return { dimensions: {}, dimensionKeys: [], hasDimensions: false };
+  }
+}
+
+/**
+ * Displays external files validation results
+ * @function displayExternalFilesValidation
+ * @param {Array} externalFiles - External files validation results
+ */
+function displayExternalFilesValidation(externalFiles) {
+  if (!externalFiles || externalFiles.length === 0) {
+    return;
+  }
+
+  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(`  ✗ ${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}`));
+      });
+    }
+  });
+}
+
+/**
+ * Displays Dimensions (ABAC) validation results for datasources
+ * @function displayDimensionsValidation
+ * @param {Array} externalFiles - External files validation results
+ * @returns {Array} Warnings to add to aggregated warnings
+ */
+function displayDimensionsValidation(externalFiles) {
+  if (!externalFiles || externalFiles.length === 0) {
+    return [];
+  }
+
+  const datasourceFiles = externalFiles.filter(f =>
+    f.type === 'datasource' || f.type === 'external-datasource'
+  );
+
+  if (datasourceFiles.length === 0) {
+    return [];
+  }
+
+  logger.log(chalk.blue('\nDimensions (ABAC):'));
+
+  const warnings = [];
+  let anyDatasourceHasDimensions = false;
+
+  datasourceFiles.forEach(file => {
+    const dimensionsInfo = extractDimensionsFromDatasource(file.path);
+
+    if (dimensionsInfo.hasDimensions) {
+      anyDatasourceHasDimensions = true;
+      logger.log(chalk.green(`  ✓ ${file.file}`));
+      dimensionsInfo.dimensionKeys.forEach(key => {
+        const mapping = dimensionsInfo.dimensions[key];
+        logger.log(chalk.gray(`      ${key} → ${mapping}`));
+      });
+    } else {
+      logger.log(chalk.yellow(`  ⚠ ${file.file} - no dimensions configured`));
+      warnings.push(`${file.file} - no dimensions configured, ABAC filtering disabled`);
+    }
+  });
+
+  if (!anyDatasourceHasDimensions) {
+    logger.log(chalk.yellow('    ⚠ No dimensions configured - ABAC filtering disabled for all datasources'));
+  }
+
+  return warnings;
+}
+
+/**
+ * Displays RBAC validation results
+ * @function displayRbacValidation
+ * @param {Object} rbac - RBAC validation result
+ */
+function displayRbacValidation(rbac) {
+  if (!rbac) {
+    return;
+  }
+
+  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}`));
+    });
+  }
+}
+
+/**
+ * Displays file validation results (for direct file validation)
+ * @function displayFileValidation
+ * @param {Object} result - Validation result
+ */
+function displayFileValidation(result) {
+  if (!result.file) {
+    return;
+  }
+
+  logger.log(chalk.blue(`\nFile: ${result.file}`));
+  logger.log(chalk.blue(`Type: ${result.type}`));
+  if (result.valid) {
+    logger.log(chalk.green('  ✓ File is valid'));
+  } else {
+    logger.log(chalk.red('  ✗ File has errors:'));
+    result.errors.forEach(error => {
+      logger.log(chalk.red(`    • ${error}`));
+    });
+  }
+  if (result.warnings && result.warnings.length > 0) {
+    result.warnings.forEach(warning => {
+      logger.log(chalk.yellow(`    ⚠ ${warning}`));
+    });
+  }
+}
+
+/**
+ * Displays aggregated warnings
+ * @function displayAggregatedWarnings
+ * @param {Array} warnings - Array of warning messages
+ */
+function displayAggregatedWarnings(warnings) {
+  if (!warnings || warnings.length === 0) {
+    return;
+  }
+
+  logger.log(chalk.yellow('\nWarnings:'));
+  warnings.forEach(warning => {
+    logger.log(chalk.yellow(`  • ${warning}`));
+  });
+}
+
+/**
+ * Displays application validation step
+ * @function displayApplicationStep
+ * @param {Object} application - Application validation result
+ * @returns {void}
+ */
+function displayApplicationStep(application) {
+  logger.log(chalk.blue('\nApplication:'));
+  if (application.valid) {
+    logger.log(chalk.green('  ✓ Application configuration is valid'));
+  } else {
+    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 integration files step
+ * @function displayComponentsStep
+ * @param {Object} components - Components validation result
+ * @returns {void}
+ */
+function displayComponentsStep(components) {
+  if (!components.files || components.files.length === 0) {
+    return;
+  }
+
+  logger.log(chalk.blue('\nExternal Integration Files:'));
+  components.files.forEach(file => {
+    if (file.valid) {
+      logger.log(chalk.green(`  ✓ ${file.file} (${file.type})`));
+    } else {
+      logger.log(chalk.red(`  ✗ ${file.file} (${file.type})`));
+    }
+  });
+
+  if (components.errors && components.errors.length > 0) {
+    components.errors.forEach(error => {
+      logger.log(chalk.red(`    • ${error}`));
+    });
+  }
+}
+
+/**
+ * Displays dimensions validation for datasources
+ * @function displayDimensionsStep
+ * @param {Array} datasourceFiles - Datasource files
+ * @returns {void}
+ */
+function displayDimensionsStep(datasourceFiles) {
+  if (datasourceFiles.length === 0) {
+    return;
+  }
+
+  logger.log(chalk.blue('\nDimensions (ABAC):'));
+  datasourceFiles.forEach(file => {
+    try {
+      const dimensionsInfo = extractDimensionsFromDatasource(file.path || file.file);
+      if (dimensionsInfo.hasDimensions) {
+        logger.log(chalk.green(`  ✓ ${file.file}`));
+        dimensionsInfo.dimensionKeys.forEach(key => {
+          const mapping = dimensionsInfo.dimensions[key];
+          logger.log(chalk.gray(`      ${key} → ${mapping}`));
+        });
+      } else {
+        logger.log(chalk.yellow(`  ⚠ ${file.file} - no dimensions configured`));
+      }
+    } catch {
+      // Skip if file path not available
+    }
+  });
+}
+
+/**
+ * Displays deployment manifest step
+ * @function displayManifestStep
+ * @param {Object} manifest - Manifest validation result
+ * @param {Array} componentFiles - Component files
+ * @returns {void}
+ */
+function displayManifestStep(manifest, componentFiles) {
+  logger.log(chalk.blue('\nDeployment Manifest:'));
+  if (manifest.valid) {
+    logger.log(chalk.green('  ✓ Full deployment manifest is valid'));
+    if (componentFiles) {
+      const datasourceFiles = componentFiles.filter(f => f.type === 'datasource' || f.type === 'external-datasource');
+      logger.log(chalk.green('    ✓ System configuration valid'));
+      logger.log(chalk.green(`    ✓ ${datasourceFiles.length} datasource(s) valid`));
+      logger.log(chalk.green('    ✓ Schema validation passed'));
+    }
+  } else {
+    logger.log(chalk.red('  ✗ Full deployment manifest validation failed:'));
+    if (manifest.errors && manifest.errors.length > 0) {
+      manifest.errors.forEach(error => {
+        logger.log(chalk.red(`    • ${error}`));
+      });
+    }
+  }
+  if (manifest.warnings && manifest.warnings.length > 0) {
+    manifest.warnings.forEach(warning => {
+      logger.log(chalk.yellow(`    ⚠ ${warning}`));
+    });
+  }
+}
+
+/**
+ * Displays step-by-step validation results for external systems
+ * @function displayStepByStepValidation
+ * @param {Object} result - Validation result with steps
+ */
+function displayStepByStepValidation(result) {
+  if (result.valid) {
+    logger.log(chalk.green('\n✓ Validation passed!'));
+  } else {
+    logger.log(chalk.red('\n✗ Validation failed!'));
+  }
+
+  displayApplicationStep(result.steps.application);
+
+  if (result.steps.components.files && result.steps.components.files.length > 0) {
+    displayComponentsStep(result.steps.components);
+  }
+
+  const datasourceFiles = result.steps.components.files?.filter(f =>
+    f.type === 'datasource' || f.type === 'external-datasource'
+  ) || [];
+  displayDimensionsStep(datasourceFiles);
+
+  if (result.rbac) {
+    displayRbacValidation(result.rbac);
+  }
+
+  displayManifestStep(result.steps.manifest, result.steps.components.files);
+
+  if (result.warnings && result.warnings.length > 0) {
+    displayAggregatedWarnings(result.warnings);
+  }
+}
+
+/**
+ * Displays validation results in a user-friendly format
+ *
+ * @function displayValidationResults
+ * @param {Object} result - Validation result from validateAppOrFile
+ */
+function displayValidationResults(result) {
+  // Check if this is a step-by-step result (from validateExternalSystemComplete)
+  if (result.steps) {
+    displayStepByStepValidation(result);
+    return;
+  }
+
+  // Legacy format (for regular apps)
+  if (result.valid) {
+    logger.log(chalk.green('\n✓ Validation passed!'));
+  } else {
+    logger.log(chalk.red('\n✗ Validation failed!'));
+  }
+
+  displayApplicationValidation(result.application);
+  displayExternalFilesValidation(result.externalFiles);
+
+  // Display Dimensions (ABAC) for datasources and collect warnings
+  const dimensionWarnings = displayDimensionsValidation(result.externalFiles);
+
+  displayRbacValidation(result.rbac);
+  displayFileValidation(result);
+
+  // Combine all warnings
+  const allWarnings = [...(result.warnings || []), ...dimensionWarnings];
+  displayAggregatedWarnings(allWarnings);
+}
+
+module.exports = {
+  displayValidationResults,
+  displayStepByStepValidation,
+  displayApplicationValidation,
+  displayExternalFilesValidation,
+  displayDimensionsValidation,
+  displayRbacValidation,
+  displayFileValidation,
+  displayAggregatedWarnings,
+  extractDimensionsFromDatasource
+};