@aifabrix/builder 2.31.1 → 2.32.2

package/lib/{external-system-download.js → external-system/download.js}

@@ -14,13 +14,14 @@ const path = require('path');
 const os = require('os');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const { getExternalSystemConfig } = require('./api/external-systems.api');
-const { getDeploymentAuth } = require('./utils/token-manager');
-const { getDataplaneUrl } = require('./datasource-deploy');
-const { getConfig } = require('./config');
-const { detectAppType } = require('./utils/paths');
-const logger = require('./utils/logger');
-const { generateEnvTemplate } = require('./utils/external-system-env-helpers');
+const { getExternalSystemConfig } = require('../api/external-systems.api');
+const { getDeploymentAuth } = require('../utils/token-manager');
+const { getDataplaneUrl } = require('../datasource/deploy');
+const { getConfig } = require('../core/config');
+const { detectAppType } = require('../utils/paths');
+const logger = require('../utils/logger');
+const { generateEnvTemplate } = require('../utils/external-system-env-helpers');
+const { generateVariablesYaml, generateReadme } = require('./download-helpers');
 
 /**
  * Validates system type from downloaded application
@@ -49,30 +50,49 @@ function validateSystemType(application) {
  * @param {Array} dataSources - Array of datasource configurations
  * @throws {Error} If validation fails
  */
-function validateDownloadedData(application, dataSources) {
+/**
+ * Validates application configuration
+ * @function validateApplicationConfig
+ * @param {Object} application - Application configuration
+ * @throws {Error} If validation fails
+ */
+function validateApplicationConfig(application) {
   if (!application || typeof application !== 'object') {
     throw new Error('Application configuration is required');
   }
-
   if (!application.key || typeof application.key !== 'string') {
     throw new Error('Application key is required');
   }
+}
+
+/**
+ * Validates datasource configuration
+ * @function validateDatasourceConfig
+ * @param {Object} datasource - Datasource configuration
+ * @param {string} applicationKey - Application key
+ * @throws {Error} If validation fails
+ */
+function validateDatasourceConfig(datasource, applicationKey) {
+  if (!datasource.key || typeof datasource.key !== 'string') {
+    throw new Error('Datasource key is required for all datasources');
+  }
+  if (!datasource.systemKey || typeof datasource.systemKey !== 'string') {
+    throw new Error('Datasource systemKey is required for all datasources');
+  }
+  if (datasource.systemKey !== applicationKey) {
+    throw new Error(`Datasource systemKey (${datasource.systemKey}) does not match application key (${applicationKey})`);
+  }
+}
+
+function validateDownloadedData(application, dataSources) {
+  validateApplicationConfig(application);
 
   if (!Array.isArray(dataSources)) {
     throw new Error('DataSources must be an array');
   }
 
-  // Validate each datasource has required fields
   for (const datasource of dataSources) {
-    if (!datasource.key || typeof datasource.key !== 'string') {
-      throw new Error('Datasource key is required for all datasources');
-    }
-    if (!datasource.systemKey || typeof datasource.systemKey !== 'string') {
-      throw new Error('Datasource systemKey is required for all datasources');
-    }
-    if (datasource.systemKey !== application.key) {
-      throw new Error(`Datasource systemKey (${datasource.systemKey}) does not match application key (${application.key})`);
-    }
+    validateDatasourceConfig(datasource, application.key);
   }
 }
 
@@ -95,112 +115,6 @@ function handlePartialDownload(systemKey, systemData, datasourceErrors) {
   );
 }
 
-/**
- * Extract OAuth2 environment variables
- * @param {Object} oauth2 - OAuth2 configuration
- * @param {string} systemKey - System key
- * @param {Array<string>} lines - Lines array to append to
- */
-
-/**
- * Generates variables.yaml with externalIntegration block
- * @param {string} systemKey - System key
- * @param {Object} application - External system configuration
- * @param {Array} dataSources - Array of datasource configurations
- * @returns {Object} Variables YAML object
- */
-function generateVariablesYaml(systemKey, application, dataSources) {
-  const systemFileName = `${systemKey}-deploy.json`;
-  const datasourceFiles = dataSources.map(ds => {
-    // Extract entity key from datasource key or use entityKey
-    const entityKey = ds.entityKey || ds.key.split('-').pop();
-    return `${systemKey}-deploy-${entityKey}.json`;
-  });
-
-  return {
-    name: systemKey,
-    displayName: application.displayName || systemKey,
-    description: application.description || `External system integration for ${systemKey}`,
-    externalIntegration: {
-      schemaBasePath: './',
-      systems: [systemFileName],
-      dataSources: datasourceFiles,
-      autopublish: false,
-      version: application.version || '1.0.0'
-    }
-  };
-}
-
-/**
- * Generates README.md with setup instructions
- * @param {string} systemKey - System key
- * @param {Object} application - External system configuration
- * @param {Array} dataSources - Array of datasource configurations
- * @returns {string} README.md content
- */
-function generateReadme(systemKey, application, dataSources) {
-  const displayName = application.displayName || systemKey;
-  const description = application.description || `External system integration for ${systemKey}`;
-  const systemType = application.type || 'unknown';
-
-  const lines = [
-    `# ${displayName}`,
-    '',
-    description,
-    '',
-    '## System Information',
-    '',
-    `- **System Key**: \`${systemKey}\``,
-    `- **System Type**: \`${systemType}\``,
-    `- **Datasources**: ${dataSources.length}`,
-    '',
-    '## Files',
-    '',
-    '- `variables.yaml` - Application configuration with externalIntegration block',
-    `- \`${systemKey}-deploy.json\` - External system definition`
-  ];
-
-  dataSources.forEach(ds => {
-    const entityKey = ds.entityKey || ds.key.split('-').pop();
-    lines.push(`- \`${systemKey}-deploy-${entityKey}.json\` - Datasource: ${ds.displayName || ds.key}`);
-  });
-
-  lines.push(
-    '- `env.template` - Environment variables template',
-    '',
-    '## Setup Instructions',
-    '',
-    '1. Review and update configuration files as needed',
-    '2. Set up environment variables in `env.template`',
-    '3. Run unit tests: `aifabrix test ${systemKey}`',
-    '4. Run integration tests: `aifabrix test-integration ${systemKey}`',
-    '5. Deploy: `aifabrix deploy ${systemKey} --environment dev`',
-    '',
-    '## Testing',
-    '',
-    '### Unit Tests',
-    'Run local validation without API calls:',
-    '```bash',
-    `aifabrix test ${systemKey}`,
-    '```',
-    '',
-    '### Integration Tests',
-    'Run integration tests via dataplane:',
-    '```bash',
-    `aifabrix test-integration ${systemKey} --environment dev`,
-    '```',
-    '',
-    '## Deployment',
-    '',
-    'Deploy to dataplane via miso-controller:',
-    '```bash',
-    `aifabrix deploy ${systemKey} --environment dev`,
-    '```'
-  );
-
-  return lines.join('\n');
-}
-
 /**
  * Setup authentication and get dataplane URL
  * @async
@@ -264,18 +178,38 @@ async function downloadSystemConfiguration(dataplaneUrl, systemKey, authConfig)
  * @returns {Promise<Object>} Object with file paths
  * @throws {Error} If file generation fails
  */
-async function generateFilesInTempDir(tempDir, systemKey, application, dataSources) {
+/**
+ * Generates system file
+ * @async
+ * @function generateSystemFile
+ * @param {string} tempDir - Temporary directory
+ * @param {string} systemKey - System key
+ * @param {Object} application - Application object
+ * @returns {Promise<string>} System file path
+ */
+async function generateSystemFile(tempDir, systemKey, application) {
   const systemFileName = `${systemKey}-deploy.json`;
   const systemFilePath = path.join(tempDir, systemFileName);
   await fs.writeFile(systemFilePath, JSON.stringify(application, null, 2), 'utf8');
+  return systemFilePath;
+}
 
-  // Generate datasource files
+/**
+ * Generates datasource files
+ * @async
+ * @function generateDatasourceFiles
+ * @param {string} tempDir - Temporary directory
+ * @param {string} systemKey - System key
+ * @param {Array} dataSources - Array of datasource objects
+ * @returns {Promise<Object>} Object with datasourceFiles array and datasourceErrors array
+ */
+async function generateDatasourceFiles(tempDir, systemKey, dataSources) {
   const datasourceErrors = [];
   const datasourceFiles = [];
   for (const datasource of dataSources) {
     try {
-      const entityKey = datasource.entityKey || datasource.key.split('-').pop();
-      const datasourceFileName = `${systemKey}-deploy-${entityKey}.json`;
+      const entityType = datasource.entityType || datasource.entityKey || datasource.key.split('-').pop();
+      const datasourceFileName = `${systemKey}-deploy-${entityType}.json`;
       const datasourceFilePath = path.join(tempDir, datasourceFileName);
       await fs.writeFile(datasourceFilePath, JSON.stringify(datasource, null, 2), 'utf8');
       datasourceFiles.push(datasourceFilePath);
@@ -283,12 +217,20 @@ async function generateFilesInTempDir(tempDir, systemKey, application, dataSourc
       datasourceErrors.push(new Error(`Failed to write datasource ${datasource.key}: ${error.message}`));
     }
   }
+  return { datasourceFiles, datasourceErrors };
+}
 
-  // Handle partial downloads
-  if (datasourceErrors.length > 0) {
-    handlePartialDownload(systemKey, application, datasourceErrors);
-  }
-
+/**
+ * Generates configuration files (variables.yaml, env.template, README.md)
+ * @async
+ * @function generateConfigFiles
+ * @param {string} tempDir - Temporary directory
+ * @param {string} systemKey - System key
+ * @param {Object} application - Application object
+ * @param {Array} dataSources - Array of datasource objects
+ * @returns {Promise<Object>} Object with file paths
+ */
+async function generateConfigFiles(tempDir, systemKey, application, dataSources) {
   // Generate variables.yaml
   const variables = generateVariablesYaml(systemKey, application, dataSources);
   const variablesPath = path.join(tempDir, 'variables.yaml');
@@ -304,6 +246,21 @@ async function generateFilesInTempDir(tempDir, systemKey, application, dataSourc
   const readmePath = path.join(tempDir, 'README.md');
   await fs.writeFile(readmePath, readme, 'utf8');
 
+  return { variablesPath, envTemplatePath, readmePath };
+}
+
+async function generateFilesInTempDir(tempDir, systemKey, application, dataSources) {
+  const systemFilePath = await generateSystemFile(tempDir, systemKey, application);
+
+  const { datasourceFiles, datasourceErrors } = await generateDatasourceFiles(tempDir, systemKey, dataSources);
+
+  // Handle partial downloads
+  if (datasourceErrors.length > 0) {
+    handlePartialDownload(systemKey, application, datasourceErrors);
+  }
+
+  const { variablesPath, envTemplatePath, readmePath } = await generateConfigFiles(tempDir, systemKey, application, dataSources);
+
   return {
     systemFilePath,
     variablesPath,
@@ -490,7 +447,7 @@ module.exports = {
   validateSystemType,
   validateDownloadedData,
   generateVariablesYaml,
-  generateEnvTemplate,
   generateReadme,
+  generateEnvTemplate,
   handlePartialDownload
 };

package/lib/{external-system-generator.js → external-system/generator.js}

@@ -14,7 +14,7 @@ const path = require('path');
 const handlebars = require('handlebars');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const logger = require('./utils/logger');
+const logger = require('../utils/logger');
 
 // Register Handlebars helper for equality check
 handlebars.registerHelper('eq', (a, b) => a === b);
@@ -31,7 +31,7 @@ handlebars.registerHelper('eq', (a, b) => a === b);
  */
 async function generateExternalSystemTemplate(appPath, systemKey, config) {
   try {
-    const templatePath = path.join(__dirname, '..', 'templates', 'external-system', 'external-system.json.hbs');
+    const templatePath = path.join(__dirname, '..', '..', 'templates', 'external-system', 'external-system.json.hbs');
     const templateContent = await fs.readFile(templatePath, 'utf8');
     const template = handlebars.compile(templateContent);
 
@@ -70,7 +70,7 @@ async function generateExternalSystemTemplate(appPath, systemKey, config) {
  */
 async function generateExternalDataSourceTemplate(appPath, datasourceKey, config) {
   try {
-    const templatePath = path.join(__dirname, '..', 'templates', 'external-system', 'external-datasource.json.hbs');
+    const templatePath = path.join(__dirname, '..', '..', 'templates', 'external-system', 'external-datasource.json.hbs');
     const templateContent = await fs.readFile(templatePath, 'utf8');
     const template = handlebars.compile(templateContent);
 
@@ -79,9 +79,11 @@ async function generateExternalDataSourceTemplate(appPath, datasourceKey, config
       datasourceDisplayName: config.datasourceDisplayName || datasourceKey.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
       datasourceDescription: config.datasourceDescription || `External datasource for ${datasourceKey}`,
       systemKey: config.systemKey,
-      entityKey: config.entityKey || datasourceKey.split('-').pop(),
+      entityType: config.entityType || datasourceKey.split('-').pop(),
       resourceType: config.resourceType || 'document',
-      systemType: config.systemType || 'openapi'
+      systemType: config.systemType || 'openapi',
+      dimensions: config.dimensions || {},
+      attributes: config.attributes || {}
     };
 
     const rendered = template(context);
@@ -121,18 +123,20 @@ async function generateExternalSystemFiles(appPath, appName, config) {
     const resourceTypes = ['customer', 'contact', 'person', 'document', 'deal'];
 
     for (let i = 0; i < datasourceCount; i++) {
-      const entityKey = `entity${i + 1}`;
-      // For datasource key, use just the entity key (will be prefixed with app-name-deploy-)
-      const datasourceKey = entityKey;
+      const entityType = `entity${i + 1}`;
+      // For datasource key, use just the entity type (will be prefixed with app-name-deploy-)
+      const datasourceKey = entityType;
       const resourceType = resourceTypes[i % resourceTypes.length];
 
       const datasourceConfig = {
         systemKey: systemKey,
-        entityKey: entityKey,
+        entityType: entityType,
         resourceType: resourceType,
         systemType: config.systemType || 'openapi',
-        datasourceDisplayName: `${config.systemDisplayName || systemKey} ${entityKey}`,
-        datasourceDescription: `External datasource for ${entityKey} entity`
+        datasourceDisplayName: `${config.systemDisplayName || systemKey} ${entityType}`,
+        datasourceDescription: `External datasource for ${entityType} entity`,
+        dimensions: config.dimensions || {},
+        attributes: config.attributes || {}
       };
 
       // Generate with full naming: <app-name>-deploy-<entity-key>.json

package/lib/external-system/test-auth.js

@@ -0,0 +1,40 @@
+/**
+ * External System Test Authentication Helpers
+ *
+ * Authentication setup for integration tests
+ *
+ * @fileoverview Authentication helpers for external system testing
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { getDeploymentAuth } = require('../utils/token-manager');
+const { getDataplaneUrl } = require('../datasource/deploy');
+
+/**
+ * Setup authentication and get dataplane URL for integration tests
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Test options
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} Object with authConfig and dataplaneUrl
+ * @throws {Error} If authentication fails
+ */
+async function setupIntegrationTestAuth(appName, options, config) {
+  const environment = options.environment || 'dev';
+  const controllerUrl = options.controller || config.deployment?.controllerUrl || 'http://localhost:3000';
+  const authConfig = await getDeploymentAuth(controllerUrl, environment, appName);
+
+  if (!authConfig.token && !authConfig.clientId) {
+    throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
+  }
+
+  const dataplaneUrl = await getDataplaneUrl(controllerUrl, appName, environment, authConfig);
+
+  return { authConfig, dataplaneUrl };
+}
+
+module.exports = {
+  setupIntegrationTestAuth
+};
+

package/lib/external-system/test-execution.js

@@ -0,0 +1,84 @@
+/**
+ * External System Test Execution
+ *
+ * Test execution functions for integration tests
+ *
+ * @fileoverview Test execution utilities for external system testing
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const testHelpers = require('../utils/external-system-test-helpers');
+
+/**
+ * Executes test for a single datasource
+ * @async
+ * @function executeDatasourceTest
+ * @param {string} systemKey - System key
+ * @param {string} datasourceKey - Datasource key
+ * @param {Object} payloadTemplate - Payload template
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Test options
+ * @returns {Promise<Object>} Test result
+ */
+async function executeDatasourceTest(systemKey, datasourceKey, payloadTemplate, dataplaneUrl, authConfig, options) {
+  try {
+    const datasourceResult = await testHelpers.testSingleDatasource({
+      systemKey,
+      datasourceKey,
+      payloadTemplate,
+      dataplaneUrl,
+      authConfig,
+      timeout: parseInt(options.timeout, 10) || 30000
+    });
+    return datasourceResult;
+  } catch (error) {
+    return {
+      key: datasourceKey,
+      skipped: false,
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Tests a single datasource integration
+ * @async
+ * @function testSingleDatasourceIntegration
+ * @param {Object} datasourceFile - Datasource file object
+ * @param {string} systemKey - System key
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} customPayload - Custom payload
+ * @param {Object} options - Test options
+ * @returns {Promise<Object>} Test result
+ */
+async function testSingleDatasourceIntegration(datasourceFile, systemKey, dataplaneUrl, authConfig, customPayload, options) {
+  const datasource = datasourceFile.data;
+  const datasourceKey = datasource.key;
+
+  logger.log(chalk.blue(`\n📡 Testing datasource: ${datasourceKey}`));
+
+  // Determine payload to use
+  const payloadTemplate = testHelpers.determinePayloadTemplate(datasource, datasourceKey, customPayload);
+  if (!payloadTemplate) {
+    logger.log(chalk.yellow(`  ⚠ No test payload found for ${datasourceKey}, skipping...`));
+    return {
+      key: datasourceKey,
+      skipped: true,
+      reason: 'No test payload available'
+    };
+  }
+
+  return await executeDatasourceTest(systemKey, datasourceKey, payloadTemplate, dataplaneUrl, authConfig, options);
+}
+
+module.exports = {
+  executeDatasourceTest,
+  testSingleDatasourceIntegration
+};
+

package/lib/external-system/test-helpers.js

@@ -0,0 +1,109 @@
+/**
+ * External System Test Helpers
+ *
+ * Helper functions for external system testing
+ *
+ * @fileoverview Test helper utilities for external system testing
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const externalSystemSchema = require('../schema/external-system.schema.json');
+const { validateAgainstSchema } = require('../utils/external-system-validators');
+
+/**
+ * Initialize test results object
+ * @function initializeTestResults
+ * @returns {Object} Initial test results
+ */
+function initializeTestResults() {
+  return {
+    valid: true,
+    errors: [],
+    warnings: [],
+    systemResults: [],
+    datasourceResults: []
+  };
+}
+
+/**
+ * Validates system files against schema
+ * @function validateSystemFiles
+ * @param {Array} systemFiles - Array of system file objects with data property
+ * @param {Object} schema - External system schema
+ * @returns {Object} Validation results
+ */
+function validateSystemFiles(systemFiles, schema) {
+  const systemResults = [];
+  let valid = true;
+  const errors = [];
+
+  for (const systemFile of systemFiles) {
+    const validation = validateAgainstSchema(systemFile.data, schema);
+    if (!validation.valid) {
+      valid = false;
+      errors.push(...validation.errors);
+    }
+    systemResults.push({
+      file: systemFile.path || systemFile.file,
+      valid: validation.valid,
+      errors: validation.errors || []
+    });
+  }
+
+  return { valid, errors, systemResults };
+}
+
+/**
+ * Validates system files and updates results
+ * @function validateSystemFilesForTest
+ * @param {Array} systemFiles - System files
+ * @param {Object} results - Test results object
+ */
+function validateSystemFilesForTest(systemFiles, results) {
+  logger.log(chalk.blue('📋 Validating system files...'));
+  const systemValidation = validateSystemFiles(systemFiles, externalSystemSchema);
+  results.valid = systemValidation.valid;
+  results.errors.push(...systemValidation.errors);
+  results.systemResults = systemValidation.systemResults;
+}
+
+/**
+ * Validates datasource files and updates results
+ * @function validateDatasourceFilesForTest
+ * @param {Array} datasourceFiles - Datasource files
+ * @param {Array} systemFiles - System files
+ * @param {Object} results - Test results object
+ * @param {Object} options - Test options
+ * @param {Function} validateSingleDatasource - Function to validate single datasource
+ * @param {Function} determineDatasourcesToTest - Function to determine datasources to test
+ */
+function validateDatasourceFilesForTest(datasourceFiles, systemFiles, results, options, validateSingleDatasource, determineDatasourcesToTest) {
+  logger.log(chalk.blue('📋 Validating datasource files...'));
+  const datasourcesToTest = determineDatasourcesToTest(datasourceFiles, options.datasource);
+  const systemKey = systemFiles.length > 0 ? systemFiles[0].data.key : null;
+
+  for (const datasourceFile of datasourcesToTest) {
+    const datasourceResult = validateSingleDatasource(
+      datasourceFile,
+      systemKey,
+      require('../schema/external-datasource.schema.json'),
+      options.verbose
+    );
+
+    if (!datasourceResult.valid) {
+      results.valid = false;
+    }
+
+    results.datasourceResults.push(datasourceResult);
+  }
+}
+
+module.exports = {
+  initializeTestResults,
+  validateSystemFilesForTest,
+  validateDatasourceFilesForTest
+};
+