@aifabrix/builder 2.6.2 → 2.7.0

package/lib/datasource-validate.js

@@ -0,0 +1,63 @@
+/**
+ * Datasource Validation
+ *
+ * Validates external datasource JSON files against schema.
+ *
+ * @fileoverview Datasource validation for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const { loadExternalDataSourceSchema } = require('./utils/schema-loader');
+const { formatValidationErrors } = require('./utils/error-formatter');
+
+/**
+ * Validates a datasource file against external-datasource schema
+ *
+ * @async
+ * @function validateDatasourceFile
+ * @param {string} filePath - Path to the datasource JSON file
+ * @returns {Promise<Object>} Validation result with errors and warnings
+ * @throws {Error} If file cannot be read or parsed
+ *
+ * @example
+ * const result = await validateDatasourceFile('./hubspot-deal.json');
+ * // Returns: { valid: true, errors: [], warnings: [] }
+ */
+async function validateDatasourceFile(filePath) {
+  if (!filePath || typeof filePath !== 'string') {
+    throw new Error('File path is required and must be a string');
+  }
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  let parsed;
+
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [`Invalid JSON syntax: ${error.message}`],
+      warnings: []
+    };
+  }
+
+  const validate = loadExternalDataSourceSchema();
+  const valid = validate(parsed);
+
+  return {
+    valid,
+    errors: valid ? [] : formatValidationErrors(validate.errors),
+    warnings: []
+  };
+}
+
+module.exports = {
+  validateDatasourceFile
+};
+

package/lib/diff.js

@@ -0,0 +1,266 @@
+/**
+ * File Comparison Utilities
+ *
+ * Compares two configuration files and identifies differences.
+ * Used for deployment pipeline validation and schema migration detection.
+ *
+ * @fileoverview File comparison utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('./utils/logger');
+
+/**
+ * Performs deep comparison of two objects
+ * Returns differences as structured result
+ *
+ * @function compareObjects
+ * @param {Object} obj1 - First object
+ * @param {Object} obj2 - Second object
+ * @param {string} [path=''] - Current path in object (for nested fields)
+ * @returns {Object} Comparison result with added, removed, changed fields
+ */
+function compareObjects(obj1, obj2, currentPath = '') {
+  const result = {
+    added: [],
+    removed: [],
+    changed: [],
+    identical: true
+  };
+
+  const allKeys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
+
+  for (const key of allKeys) {
+    const newPath = currentPath ? `${currentPath}.${key}` : key;
+    const val1 = obj1 && obj1[key];
+    const val2 = obj2 && obj2[key];
+
+    if (!(key in obj1)) {
+      result.added.push({
+        path: newPath,
+        value: val2,
+        type: typeof val2
+      });
+      result.identical = false;
+    } else if (!(key in obj2)) {
+      result.removed.push({
+        path: newPath,
+        value: val1,
+        type: typeof val1
+      });
+      result.identical = false;
+    } else if (typeof val1 === 'object' && typeof val2 === 'object' && val1 !== null && val2 !== null && !Array.isArray(val1) && !Array.isArray(val2)) {
+      // Recursively compare nested objects
+      const nestedResult = compareObjects(val1, val2, newPath);
+      result.added.push(...nestedResult.added);
+      result.removed.push(...nestedResult.removed);
+      result.changed.push(...nestedResult.changed);
+      if (!nestedResult.identical) {
+        result.identical = false;
+      }
+    } else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
+      result.changed.push({
+        path: newPath,
+        oldValue: val1,
+        newValue: val2,
+        oldType: typeof val1,
+        newType: typeof val2
+      });
+      result.identical = false;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Identifies breaking changes in comparison result
+ * Breaking changes include: removed required fields, type changes
+ *
+ * @function identifyBreakingChanges
+ * @param {Object} comparison - Comparison result from compareObjects
+ * @param {Object} schema1 - First file schema (optional, for required fields check)
+ * @param {Object} schema2 - Second file schema (optional, for required fields check)
+ * @returns {Array} Array of breaking change descriptions
+ */
+function identifyBreakingChanges(comparison) {
+  const breaking = [];
+
+  // Removed fields are potentially breaking
+  comparison.removed.forEach(removed => {
+    breaking.push({
+      type: 'removed_field',
+      path: removed.path,
+      description: `Field removed: ${removed.path} (${removed.type})`
+    });
+  });
+
+  // Type changes are breaking
+  comparison.changed.forEach(change => {
+    if (change.oldType !== change.newType) {
+      breaking.push({
+        type: 'type_change',
+        path: change.path,
+        description: `Type changed: ${change.path} (${change.oldType} → ${change.newType})`
+      });
+    }
+  });
+
+  return breaking;
+}
+
+/**
+ * Compares two configuration files
+ * Loads files, parses JSON, and performs deep comparison
+ *
+ * @async
+ * @function compareFiles
+ * @param {string} file1 - Path to first file
+ * @param {string} file2 - Path to second file
+ * @returns {Promise<Object>} Comparison result with differences
+ * @throws {Error} If files cannot be read or parsed
+ *
+ * @example
+ * const result = await compareFiles('./old.json', './new.json');
+ * // Returns: { identical: false, added: [...], removed: [...], changed: [...] }
+ */
+async function compareFiles(file1, file2) {
+  if (!file1 || typeof file1 !== 'string') {
+    throw new Error('First file path is required');
+  }
+  if (!file2 || typeof file2 !== 'string') {
+    throw new Error('Second file path is required');
+  }
+
+  // Validate files exist
+  if (!fs.existsSync(file1)) {
+    throw new Error(`File not found: ${file1}`);
+  }
+  if (!fs.existsSync(file2)) {
+    throw new Error(`File not found: ${file2}`);
+  }
+
+  // Read and parse files
+  let content1, content2;
+  let parsed1, parsed2;
+
+  try {
+    content1 = fs.readFileSync(file1, 'utf8');
+    parsed1 = JSON.parse(content1);
+  } catch (error) {
+    throw new Error(`Failed to parse ${file1}: ${error.message}`);
+  }
+
+  try {
+    content2 = fs.readFileSync(file2, 'utf8');
+    parsed2 = JSON.parse(content2);
+  } catch (error) {
+    throw new Error(`Failed to parse ${file2}: ${error.message}`);
+  }
+
+  // Compare objects
+  const comparison = compareObjects(parsed1, parsed2);
+
+  // Check for version changes
+  const version1 = parsed1.version || parsed1.metadata?.version || 'unknown';
+  const version2 = parsed2.version || parsed2.metadata?.version || 'unknown';
+  const versionChanged = version1 !== version2;
+
+  // Identify breaking changes
+  const breakingChanges = identifyBreakingChanges(comparison);
+
+  return {
+    identical: comparison.identical && !versionChanged,
+    file1: path.basename(file1),
+    file2: path.basename(file2),
+    version1,
+    version2,
+    versionChanged,
+    added: comparison.added,
+    removed: comparison.removed,
+    changed: comparison.changed,
+    breakingChanges,
+    summary: {
+      totalAdded: comparison.added.length,
+      totalRemoved: comparison.removed.length,
+      totalChanged: comparison.changed.length,
+      totalBreaking: breakingChanges.length
+    }
+  };
+}
+
+/**
+ * Formats and displays diff output
+ * Shows differences in a user-friendly format with color coding
+ *
+ * @function formatDiffOutput
+ * @param {Object} diffResult - Comparison result from compareFiles
+ */
+function formatDiffOutput(diffResult) {
+  logger.log(chalk.blue(`\nComparing: ${diffResult.file1} ↔ ${diffResult.file2}`));
+
+  if (diffResult.identical) {
+    logger.log(chalk.green('\n✓ Files are identical'));
+    return;
+  }
+
+  logger.log(chalk.yellow('\nFiles are different'));
+
+  // Version information
+  if (diffResult.versionChanged) {
+    logger.log(chalk.blue(`\nVersion: ${diffResult.version1} → ${diffResult.version2}`));
+  }
+
+  // Breaking changes
+  if (diffResult.breakingChanges.length > 0) {
+    logger.log(chalk.red('\n⚠️  Breaking Changes:'));
+    diffResult.breakingChanges.forEach(change => {
+      logger.log(chalk.red(`  • ${change.description}`));
+    });
+  }
+
+  // Added fields
+  if (diffResult.added.length > 0) {
+    logger.log(chalk.green('\nAdded Fields:'));
+    diffResult.added.forEach(field => {
+      logger.log(chalk.green(`  + ${field.path}: ${JSON.stringify(field.value)}`));
+    });
+  }
+
+  // Removed fields
+  if (diffResult.removed.length > 0) {
+    logger.log(chalk.red('\nRemoved Fields:'));
+    diffResult.removed.forEach(field => {
+      logger.log(chalk.red(`  - ${field.path}: ${JSON.stringify(field.value)}`));
+    });
+  }
+
+  // Changed fields
+  if (diffResult.changed.length > 0) {
+    logger.log(chalk.yellow('\nChanged Fields:'));
+    diffResult.changed.forEach(change => {
+      logger.log(chalk.yellow(`  ~ ${change.path}:`));
+      logger.log(chalk.gray(`    Old: ${JSON.stringify(change.oldValue)}`));
+      logger.log(chalk.gray(`    New: ${JSON.stringify(change.newValue)}`));
+    });
+  }
+
+  // Summary
+  logger.log(chalk.blue('\nSummary:'));
+  logger.log(chalk.blue(`  Added: ${diffResult.summary.totalAdded}`));
+  logger.log(chalk.blue(`  Removed: ${diffResult.summary.totalRemoved}`));
+  logger.log(chalk.blue(`  Changed: ${diffResult.summary.totalChanged}`));
+  logger.log(chalk.blue(`  Breaking: ${diffResult.summary.totalBreaking}`));
+}
+
+module.exports = {
+  compareFiles,
+  formatDiffOutput,
+  compareObjects,
+  identifyBreakingChanges
+};
+