@aifabrix/builder 2.7.0 → 2.8.0

package/lib/external-system-deploy.js

@@ -0,0 +1,262 @@
+/**
+ * External System Deployment Module
+ *
+ * Handles deployment of external systems and datasources via pipeline API
+ * for external type applications.
+ *
+ * @fileoverview External system deployment for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+const chalk = require('chalk');
+const { authenticatedApiCall } = require('./utils/api');
+const { getDeploymentAuth } = require('./utils/token-manager');
+const { getConfig } = require('./config');
+const logger = require('./utils/logger');
+const { getDataplaneUrl } = require('./datasource-deploy');
+
+/**
+ * Loads variables.yaml for an application
+ * @async
+ * @function loadVariablesYaml
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Variables configuration
+ * @throws {Error} If file cannot be loaded
+ */
+async function loadVariablesYaml(appName) {
+  const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  const content = await fs.readFile(variablesPath, 'utf8');
+  return yaml.load(content);
+}
+
+/**
+ * Validates external system files exist
+ * @async
+ * @function validateExternalSystemFiles
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Validation result with file paths
+ * @throws {Error} If validation fails
+ */
+async function validateExternalSystemFiles(appName) {
+  const variables = await loadVariablesYaml(appName);
+
+  if (!variables.externalIntegration) {
+    throw new Error('externalIntegration block not found in variables.yaml');
+  }
+
+  const appPath = path.join(process.cwd(), 'builder', appName);
+  const schemasPath = path.join(appPath, variables.externalIntegration.schemaBasePath || './schemas');
+
+  // Validate system files
+  const systemFiles = [];
+  if (variables.externalIntegration.systems && variables.externalIntegration.systems.length > 0) {
+    for (const systemFile of variables.externalIntegration.systems) {
+      const systemPath = path.join(schemasPath, systemFile);
+      try {
+        await fs.access(systemPath);
+        systemFiles.push(systemPath);
+      } catch {
+        throw new Error(`External system file not found: ${systemPath}`);
+      }
+    }
+  } else {
+    throw new Error('No external system files specified in externalIntegration.systems');
+  }
+
+  // Validate datasource files
+  const datasourceFiles = [];
+  if (variables.externalIntegration.dataSources && variables.externalIntegration.dataSources.length > 0) {
+    for (const datasourceFile of variables.externalIntegration.dataSources) {
+      const datasourcePath = path.join(schemasPath, datasourceFile);
+      try {
+        await fs.access(datasourcePath);
+        datasourceFiles.push(datasourcePath);
+      } catch {
+        throw new Error(`External datasource file not found: ${datasourcePath}`);
+      }
+    }
+  }
+
+  return {
+    systemFiles,
+    datasourceFiles,
+    systemKey: path.basename(systemFiles[0], '.json')
+  };
+}
+
+/**
+ * Deploys external system to dataplane (build step - deploy, not publish)
+ * @async
+ * @function buildExternalSystem
+ * @param {string} appName - Application name
+ * @param {Object} options - Deployment options
+ * @returns {Promise<void>} Resolves when deployment completes
+ * @throws {Error} If deployment fails
+ */
+async function buildExternalSystem(appName, options = {}) {
+  try {
+    logger.log(chalk.blue(`\n🔨 Building external system: ${appName}`));
+
+    // Validate files
+    const { systemFiles, datasourceFiles, systemKey } = await validateExternalSystemFiles(appName);
+
+    // Get authentication
+    const config = await getConfig();
+    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.');
+    }
+
+    // Get dataplane URL from controller
+    logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
+    const dataplaneUrl = await getDataplaneUrl(controllerUrl, appName, environment, authConfig);
+    logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+
+    // Deploy external system
+    logger.log(chalk.blue(`Deploying external system: ${systemKey}...`));
+    const systemContent = await fs.readFile(systemFiles[0], 'utf8');
+    const systemJson = JSON.parse(systemContent);
+
+    const systemResponse = await authenticatedApiCall(
+      `${dataplaneUrl}/api/v1/pipeline/deploy`,
+      {
+        method: 'POST',
+        body: JSON.stringify(systemJson)
+      },
+      authConfig.token
+    );
+
+    if (!systemResponse.success) {
+      throw new Error(`Failed to deploy external system: ${systemResponse.error || systemResponse.formattedError}`);
+    }
+
+    logger.log(chalk.green(`✓ External system deployed: ${systemKey}`));
+
+    // Deploy datasources
+    for (const datasourceFile of datasourceFiles) {
+      const datasourceName = path.basename(datasourceFile, '.json');
+      logger.log(chalk.blue(`Deploying datasource: ${datasourceName}...`));
+
+      const datasourceContent = await fs.readFile(datasourceFile, 'utf8');
+      const datasourceJson = JSON.parse(datasourceContent);
+
+      const datasourceResponse = await authenticatedApiCall(
+        `${dataplaneUrl}/api/v1/pipeline/${systemKey}/deploy`,
+        {
+          method: 'POST',
+          body: JSON.stringify(datasourceJson)
+        },
+        authConfig.token
+      );
+
+      if (!datasourceResponse.success) {
+        throw new Error(`Failed to deploy datasource ${datasourceName}: ${datasourceResponse.error || datasourceResponse.formattedError}`);
+      }
+
+      logger.log(chalk.green(`✓ Datasource deployed: ${datasourceName}`));
+    }
+
+    logger.log(chalk.green('\n✅ External system built successfully!'));
+    logger.log(chalk.blue(`System: ${systemKey}`));
+    logger.log(chalk.blue(`Datasources: ${datasourceFiles.length}`));
+  } catch (error) {
+    throw new Error(`Failed to build external system: ${error.message}`);
+  }
+}
+
+/**
+ * Publishes external system to dataplane (deploy step - publish)
+ * @async
+ * @function deployExternalSystem
+ * @param {string} appName - Application name
+ * @param {Object} options - Deployment options
+ * @returns {Promise<void>} Resolves when deployment completes
+ * @throws {Error} If deployment fails
+ */
+async function deployExternalSystem(appName, options = {}) {
+  try {
+    logger.log(chalk.blue(`\n🚀 Publishing external system: ${appName}`));
+
+    // Validate files
+    const { systemFiles, datasourceFiles, systemKey } = await validateExternalSystemFiles(appName);
+
+    // Get authentication
+    const config = await getConfig();
+    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.');
+    }
+
+    // Get dataplane URL from controller
+    logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
+    const dataplaneUrl = await getDataplaneUrl(controllerUrl, appName, environment, authConfig);
+    logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+
+    // Publish external system
+    logger.log(chalk.blue(`Publishing external system: ${systemKey}...`));
+    const systemContent = await fs.readFile(systemFiles[0], 'utf8');
+    const systemJson = JSON.parse(systemContent);
+
+    const systemResponse = await authenticatedApiCall(
+      `${dataplaneUrl}/api/v1/pipeline/publish`,
+      {
+        method: 'POST',
+        body: JSON.stringify(systemJson)
+      },
+      authConfig.token
+    );
+
+    if (!systemResponse.success) {
+      throw new Error(`Failed to publish external system: ${systemResponse.error || systemResponse.formattedError}`);
+    }
+
+    logger.log(chalk.green(`✓ External system published: ${systemKey}`));
+
+    // Publish datasources
+    for (const datasourceFile of datasourceFiles) {
+      const datasourceName = path.basename(datasourceFile, '.json');
+      logger.log(chalk.blue(`Publishing datasource: ${datasourceName}...`));
+
+      const datasourceContent = await fs.readFile(datasourceFile, 'utf8');
+      const datasourceJson = JSON.parse(datasourceContent);
+
+      const datasourceResponse = await authenticatedApiCall(
+        `${dataplaneUrl}/api/v1/pipeline/${systemKey}/publish`,
+        {
+          method: 'POST',
+          body: JSON.stringify(datasourceJson)
+        },
+        authConfig.token
+      );
+
+      if (!datasourceResponse.success) {
+        throw new Error(`Failed to publish datasource ${datasourceName}: ${datasourceResponse.error || datasourceResponse.formattedError}`);
+      }
+
+      logger.log(chalk.green(`✓ Datasource published: ${datasourceName}`));
+    }
+
+    logger.log(chalk.green('\n✅ External system published successfully!'));
+    logger.log(chalk.blue(`System: ${systemKey}`));
+    logger.log(chalk.blue(`Datasources: ${datasourceFiles.length}`));
+  } catch (error) {
+    throw new Error(`Failed to deploy external system: ${error.message}`);
+  }
+}
+
+module.exports = {
+  buildExternalSystem,
+  deployExternalSystem,
+  validateExternalSystemFiles
+};
+

package/lib/external-system-generator.js

@@ -0,0 +1,187 @@
+/**
+ * External System Template Generation Module
+ *
+ * Generates external system and datasource JSON files from Handlebars templates
+ * for external type applications.
+ *
+ * @fileoverview External system template generation for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const handlebars = require('handlebars');
+const yaml = require('js-yaml');
+const chalk = require('chalk');
+const logger = require('./utils/logger');
+
+// Register Handlebars helper for equality check
+handlebars.registerHelper('eq', (a, b) => a === b);
+
+/**
+ * Generates external system JSON file from template
+ * @async
+ * @function generateExternalSystemTemplate
+ * @param {string} appPath - Application directory path
+ * @param {string} systemKey - System key
+ * @param {Object} config - System configuration
+ * @returns {Promise<string>} Path to generated file
+ * @throws {Error} If generation fails
+ */
+async function generateExternalSystemTemplate(appPath, systemKey, config) {
+  try {
+    const templatePath = path.join(__dirname, '..', 'templates', 'external-system', 'external-system.json.hbs');
+    const templateContent = await fs.readFile(templatePath, 'utf8');
+    const template = handlebars.compile(templateContent);
+
+    const context = {
+      systemKey: systemKey,
+      systemDisplayName: config.systemDisplayName || systemKey.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
+      systemDescription: config.systemDescription || `External system integration for ${systemKey}`,
+      systemType: config.systemType || 'openapi',
+      authType: config.authType || 'apikey'
+    };
+
+    const rendered = template(context);
+    const schemasDir = path.join(appPath, 'schemas');
+    await fs.mkdir(schemasDir, { recursive: true });
+
+    const outputPath = path.join(schemasDir, `${systemKey}.json`);
+    await fs.writeFile(outputPath, rendered, 'utf8');
+
+    return outputPath;
+  } catch (error) {
+    throw new Error(`Failed to generate external system template: ${error.message}`);
+  }
+}
+
+/**
+ * Generates external datasource JSON file from template
+ * @async
+ * @function generateExternalDataSourceTemplate
+ * @param {string} appPath - Application directory path
+ * @param {string} datasourceKey - Datasource key
+ * @param {Object} config - Datasource configuration
+ * @returns {Promise<string>} Path to generated file
+ * @throws {Error} If generation fails
+ */
+async function generateExternalDataSourceTemplate(appPath, datasourceKey, config) {
+  try {
+    const templatePath = path.join(__dirname, '..', 'templates', 'external-system', 'external-datasource.json.hbs');
+    const templateContent = await fs.readFile(templatePath, 'utf8');
+    const template = handlebars.compile(templateContent);
+
+    const context = {
+      datasourceKey: datasourceKey,
+      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(),
+      resourceType: config.resourceType || 'document',
+      systemType: config.systemType || 'openapi'
+    };
+
+    const rendered = template(context);
+    const schemasDir = path.join(appPath, 'schemas');
+    await fs.mkdir(schemasDir, { recursive: true });
+
+    const outputPath = path.join(schemasDir, `${datasourceKey}.json`);
+    await fs.writeFile(outputPath, rendered, 'utf8');
+
+    return outputPath;
+  } catch (error) {
+    throw new Error(`Failed to generate external datasource template: ${error.message}`);
+  }
+}
+
+/**
+ * Generates all external system files (system + datasources)
+ * @async
+ * @function generateExternalSystemFiles
+ * @param {string} appPath - Application directory path
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration with external system details
+ * @returns {Promise<Object>} Object with system and datasource file paths
+ * @throws {Error} If generation fails
+ */
+async function generateExternalSystemFiles(appPath, appName, config) {
+  try {
+    const systemKey = config.systemKey || appName;
+    const datasourceCount = config.datasourceCount || 1;
+
+    // Generate external system JSON
+    const systemPath = await generateExternalSystemTemplate(appPath, systemKey, config);
+    logger.log(chalk.green(`✓ Generated external system: ${path.basename(systemPath)}`));
+
+    // Generate datasource JSON files
+    const datasourcePaths = [];
+    const resourceTypes = ['customer', 'contact', 'person', 'document', 'deal'];
+
+    for (let i = 0; i < datasourceCount; i++) {
+      const entityKey = `entity${i + 1}`;
+      const datasourceKey = `${systemKey}-${entityKey}`;
+      const resourceType = resourceTypes[i % resourceTypes.length];
+
+      const datasourceConfig = {
+        systemKey: systemKey,
+        entityKey: entityKey,
+        resourceType: resourceType,
+        systemType: config.systemType || 'openapi',
+        datasourceDisplayName: `${config.systemDisplayName || systemKey} ${entityKey}`,
+        datasourceDescription: `External datasource for ${entityKey} entity`
+      };
+
+      const datasourcePath = await generateExternalDataSourceTemplate(appPath, datasourceKey, datasourceConfig);
+      datasourcePaths.push(datasourcePath);
+      logger.log(chalk.green(`✓ Generated datasource: ${path.basename(datasourcePath)}`));
+    }
+
+    // Update variables.yaml with externalIntegration block
+    await updateVariablesYamlWithExternalIntegration(appPath, systemKey, datasourcePaths);
+
+    return {
+      systemPath,
+      datasourcePaths
+    };
+  } catch (error) {
+    throw new Error(`Failed to generate external system files: ${error.message}`);
+  }
+}
+
+/**
+ * Updates variables.yaml with externalIntegration block
+ * @async
+ * @function updateVariablesYamlWithExternalIntegration
+ * @param {string} appPath - Application directory path
+ * @param {string} systemKey - System key
+ * @param {Array<string>} datasourcePaths - Array of datasource file paths
+ * @throws {Error} If update fails
+ */
+async function updateVariablesYamlWithExternalIntegration(appPath, systemKey, datasourcePaths) {
+  try {
+    const variablesPath = path.join(appPath, 'variables.yaml');
+    const variablesContent = await fs.readFile(variablesPath, 'utf8');
+    const variables = yaml.load(variablesContent);
+
+    // Add externalIntegration block
+    variables.externalIntegration = {
+      schemaBasePath: './schemas',
+      systems: [`${systemKey}.json`],
+      dataSources: datasourcePaths.map(p => path.basename(p)),
+      autopublish: true,
+      version: '1.0.0'
+    };
+
+    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }), 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to update variables.yaml: ${error.message}`);
+  }
+}
+
+module.exports = {
+  generateExternalSystemTemplate,
+  generateExternalDataSourceTemplate,
+  generateExternalSystemFiles
+};
+