@aifabrix/builder 2.39.3 → 2.40.2

package/lib/generator/split-variables.js

@@ -0,0 +1,149 @@
+/**
+ * Variables YAML extraction for deployment JSON split.
+ * Extracts application.yaml (variables) structure from deployment JSON.
+ *
+ * @fileoverview Split variables extraction for deployment JSON reverse conversion
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { parseImageReference } = require('./parse-image');
+
+function extractAppSection(deployment) {
+  if (!deployment.key && !deployment.displayName && !deployment.description && !deployment.type) {
+    return undefined;
+  }
+  const app = {};
+  if (deployment.key) app.key = deployment.key;
+  if (deployment.displayName) app.displayName = deployment.displayName;
+  if (deployment.description) app.description = deployment.description;
+  if (deployment.type) app.type = deployment.type;
+  if (deployment.version) app.version = deployment.version;
+  return app;
+}
+
+function extractImageSection(deployment) {
+  if (!deployment.image) return undefined;
+  const imageParts = parseImageReference(deployment.image);
+  const image = {};
+  if (imageParts.name) image.name = imageParts.name;
+  if (imageParts.registry) image.registry = imageParts.registry;
+  if (imageParts.tag) image.tag = imageParts.tag;
+  if (deployment.registryMode) image.registryMode = deployment.registryMode;
+  return image;
+}
+
+function extractRequirementsSection(deployment) {
+  if (!deployment.requiresDatabase && !deployment.requiresRedis && !deployment.requiresStorage && !deployment.databases) {
+    return undefined;
+  }
+  const requires = {};
+  if (deployment.requiresDatabase !== undefined) requires.database = deployment.requiresDatabase;
+  if (deployment.requiresRedis !== undefined) requires.redis = deployment.requiresRedis;
+  if (deployment.requiresStorage !== undefined) requires.storage = deployment.requiresStorage;
+  if (deployment.databases) requires.databases = deployment.databases;
+  return requires;
+}
+
+function extractOptionalSection(deployment, sectionName, optional) {
+  if (!deployment[sectionName]) return;
+  optional[sectionName] = sectionName === 'authentication'
+    ? { ...deployment[sectionName] }
+    : deployment[sectionName];
+}
+
+function extractOptionalSections(deployment) {
+  const optional = {};
+  const names = [
+    'healthCheck', 'authentication', 'build', 'repository', 'deployment',
+    'startupCommand', 'runtimeVersion', 'scaling', 'frontDoorRouting'
+  ];
+  for (const sectionName of names) {
+    extractOptionalSection(deployment, sectionName, optional);
+  }
+  return optional;
+}
+
+/**
+ * Portal-only configuration for application.yaml (name + portalInput per entry).
+ * @param {Array} configuration - Configuration array from deployment JSON
+ * @returns {Array<{ name: string, portalInput: Object }>}
+ */
+function extractPortalInputConfiguration(configuration) {
+  if (!Array.isArray(configuration) || configuration.length === 0) return [];
+  return configuration
+    .filter(item => item && item.portalInput && typeof item.name === 'string')
+    .map(item => ({ name: item.name, portalInput: item.portalInput }));
+}
+
+/**
+ * Datasource filename for externalIntegration.dataSources.
+ * @param {string} systemKey - System key
+ * @param {Object} datasource - Datasource from deployment.dataSources
+ * @param {number} index - Index
+ * @returns {string} Filename e.g. test-hubspot-datasource-companies-data.yaml
+ */
+function getExternalDatasourceFileName(systemKey, datasource, index) {
+  const key = datasource.key || '';
+  let suffix;
+  if (key.startsWith(`${systemKey}-deploy-`)) suffix = key.slice(`${systemKey}-deploy-`.length);
+  else if (key.startsWith(`${systemKey}-`)) suffix = key.slice(systemKey.length + 1);
+  else if (key) suffix = key;
+  else suffix = datasource.entityType || datasource.entityKey || `entity${index + 1}`;
+  return `${systemKey}-datasource-${suffix}.yaml`;
+}
+
+function extractVariablesYamlForExternal(deployment) {
+  const system = deployment.system;
+  const systemKey = system.key || 'external-system';
+  const dataSourcesList = deployment.dataSources || deployment.datasources || [];
+  const variables = {
+    app: {
+      key: systemKey,
+      displayName: system.displayName || systemKey,
+      description: system.description || `External system integration for ${systemKey}`,
+      type: 'external'
+    },
+    externalIntegration: {
+      schemaBasePath: './',
+      systems: [`${systemKey}-system.yaml`],
+      dataSources: dataSourcesList.map((ds, i) => getExternalDatasourceFileName(systemKey, ds, i)),
+      autopublish: true,
+      version: '1.0.0'
+    }
+  };
+  const portalOnlyConfig = extractPortalInputConfiguration(deployment.configuration);
+  if (portalOnlyConfig.length > 0) variables.configuration = portalOnlyConfig;
+  return variables;
+}
+
+/**
+ * Extracts deployment JSON into application config (variables) structure.
+ * @param {Object} deployment - Deployment JSON object
+ * @returns {Object} Variables YAML structure
+ */
+function extractVariablesYaml(deployment) {
+  if (!deployment || typeof deployment !== 'object') {
+    throw new Error('Deployment object is required');
+  }
+  if (deployment.system && typeof deployment.system === 'object') {
+    return extractVariablesYamlForExternal(deployment);
+  }
+  const variables = {};
+  const appSection = extractAppSection(deployment);
+  if (appSection) variables.app = appSection;
+  const imageSection = extractImageSection(deployment);
+  if (imageSection) variables.image = imageSection;
+  if (deployment.port !== undefined) variables.port = deployment.port;
+  const requirementsSection = extractRequirementsSection(deployment);
+  if (requirementsSection) variables.requires = requirementsSection;
+  Object.assign(variables, extractOptionalSections(deployment));
+  const portalOnlyConfig = extractPortalInputConfiguration(deployment.configuration);
+  if (portalOnlyConfig.length > 0) variables.configuration = portalOnlyConfig;
+  return variables;
+}
+
+module.exports = {
+  extractVariablesYaml,
+  getExternalDatasourceFileName
+};

package/lib/generator/split.js

@@ -11,6 +11,9 @@
 const fs = require('fs').promises;
 const path = require('path');
 const yaml = require('js-yaml');
+const { parseImageReference } = require('./parse-image');
+const { generateReadmeFromDeployJson } = require('./split-readme');
+const { extractVariablesYaml, getExternalDatasourceFileName } = require('./split-variables');
 
 /**
  * Converts configuration array back to env.template format
@@ -43,191 +46,6 @@ function extractEnvTemplate(configuration) {
   return lines.join('\n');
 }
 
-/**
- * Parses image reference string into components
- * @function parseImageReference
- * @param {string} imageString - Full image string (e.g., "registry/name:tag")
- * @returns {Object} Object with registry, name, and tag
- */
-function parseImageReference(imageString) {
-  if (!imageString || typeof imageString !== 'string') {
-    return { registry: null, name: null, tag: 'latest' };
-  }
-
-  // Handle format: registry/name:tag or name:tag or registry/name
-  const parts = imageString.split('/');
-  let registry = null;
-  let nameAndTag = imageString;
-
-  if (parts.length > 1) {
-    // Check if first part looks like a registry (contains .)
-    if (parts[0].includes('.')) {
-      registry = parts[0];
-      nameAndTag = parts.slice(1).join('/');
-    } else {
-      // No registry, just name:tag
-      nameAndTag = imageString;
-    }
-  }
-
-  // Split name and tag
-  const tagIndex = nameAndTag.lastIndexOf(':');
-  let name = nameAndTag;
-  let tag = 'latest';
-
-  if (tagIndex !== -1) {
-    name = nameAndTag.substring(0, tagIndex);
-    tag = nameAndTag.substring(tagIndex + 1);
-  }
-
-  return { registry, name, tag };
-}
-
-/**
- * Extract app section from deployment
- * @param {Object} deployment - Deployment JSON object
- * @returns {Object|undefined} App section or undefined
- */
-function extractAppSection(deployment) {
-  if (!deployment.key && !deployment.displayName && !deployment.description && !deployment.type) {
-    return undefined;
-  }
-
-  const app = {};
-  if (deployment.key) app.key = deployment.key;
-  if (deployment.displayName) app.displayName = deployment.displayName;
-  if (deployment.description) app.description = deployment.description;
-  if (deployment.type) app.type = deployment.type;
-  if (deployment.version) app.version = deployment.version;
-  return app;
-}
-
-/**
- * Extract image section from deployment
- * @param {Object} deployment - Deployment JSON object
- * @returns {Object|undefined} Image section or undefined
- */
-function extractImageSection(deployment) {
-  if (!deployment.image) {
-    return undefined;
-  }
-
-  const imageParts = parseImageReference(deployment.image);
-  const image = {};
-  if (imageParts.name) image.name = imageParts.name;
-  if (imageParts.registry) image.registry = imageParts.registry;
-  if (imageParts.tag) image.tag = imageParts.tag;
-  if (deployment.registryMode) image.registryMode = deployment.registryMode;
-  return image;
-}
-
-/**
- * Extract requirements section from deployment
- * @param {Object} deployment - Deployment JSON object
- * @returns {Object|undefined} Requirements section or undefined
- */
-function extractRequirementsSection(deployment) {
-  if (!deployment.requiresDatabase && !deployment.requiresRedis && !deployment.requiresStorage && !deployment.databases) {
-    return undefined;
-  }
-
-  const requires = {};
-  if (deployment.requiresDatabase !== undefined) requires.database = deployment.requiresDatabase;
-  if (deployment.requiresRedis !== undefined) requires.redis = deployment.requiresRedis;
-  if (deployment.requiresStorage !== undefined) requires.storage = deployment.requiresStorage;
-  if (deployment.databases) requires.databases = deployment.databases;
-  return requires;
-}
-
-/**
- * Extract optional sections from deployment
- * @param {Object} deployment - Deployment JSON object
- * @returns {Object} Object with optional sections
- */
-/**
- * Extracts a single optional section if present
- * @function extractOptionalSection
- * @param {Object} deployment - Deployment object
- * @param {string} sectionName - Section name to extract
- * @param {Object} optional - Optional sections object to update
- */
-function extractOptionalSection(deployment, sectionName, optional) {
-  if (deployment[sectionName]) {
-    if (sectionName === 'authentication') {
-      optional[sectionName] = { ...deployment[sectionName] };
-    } else {
-      optional[sectionName] = deployment[sectionName];
-    }
-  }
-}
-
-function extractOptionalSections(deployment) {
-  const optional = {};
-
-  const optionalSectionNames = [
-    'healthCheck',
-    'authentication',
-    'build',
-    'repository',
-    'deployment',
-    'startupCommand',
-    'runtimeVersion',
-    'scaling',
-    'frontDoorRouting',
-    'roles',
-    'permissions'
-  ];
-
-  for (const sectionName of optionalSectionNames) {
-    extractOptionalSection(deployment, sectionName, optional);
-  }
-
-  return optional;
-}
-
-/**
- * Extracts deployment JSON into variables.yaml structure
- * @function extractVariablesYaml
- * @param {Object} deployment - Deployment JSON object
- * @returns {Object} Variables YAML structure
- */
-function extractVariablesYaml(deployment) {
-  if (!deployment || typeof deployment !== 'object') {
-    throw new Error('Deployment object is required');
-  }
-
-  const variables = {};
-
-  // Extract app section
-  const appSection = extractAppSection(deployment);
-  if (appSection) {
-    variables.app = appSection;
-  }
-
-  // Extract image section
-  const imageSection = extractImageSection(deployment);
-  if (imageSection) {
-    variables.image = imageSection;
-  }
-
-  // Extract port
-  if (deployment.port !== undefined) {
-    variables.port = deployment.port;
-  }
-
-  // Extract requirements section
-  const requirementsSection = extractRequirementsSection(deployment);
-  if (requirementsSection) {
-    variables.requires = requirementsSection;
-  }
-
-  // Extract optional sections
-  const optionalSections = extractOptionalSections(deployment);
-  Object.assign(variables, optionalSections);
-
-  return variables;
-}
-
 /**
  * Extracts roles and permissions from deployment JSON
  * @function extractRbacYaml
@@ -257,62 +75,6 @@ function extractRbacYaml(deployment) {
   return rbac;
 }
 
-/**
- * Generates README.md content from deployment JSON
- * @function generateReadmeFromDeployJson
- * @param {Object} deployment - Deployment JSON object
- * @returns {string} README.md content
- */
-function generateReadmeFromDeployJson(deployment) {
-  if (!deployment || typeof deployment !== 'object') {
-    throw new Error('Deployment object is required');
-  }
-
-  const appName = deployment.key || 'application';
-  const displayName = deployment.displayName || appName;
-  const description = deployment.description || 'Application deployment configuration';
-  const port = deployment.port || 3000;
-  const image = deployment.image || 'unknown';
-
-  const lines = [
-    `# ${displayName}`,
-    '',
-    description,
-    '',
-    '## Quick Start',
-    '',
-    'This application is configured via deployment JSON and component files.',
-    '',
-    '## Configuration',
-    '',
-    `- **Application Key**: \`${appName}\``,
-    `- **Port**: \`${port}\``,
-    `- **Image**: \`${image}\``,
-    '',
-    '## Files',
-    '',
-    '- `variables.yaml` - Application configuration',
-    '- `env.template` - Environment variables template',
-    '- `rbac.yml` - Roles and permissions (if applicable)',
-    '- `README.md` - This file',
-    '',
-    '## Documentation',
-    '',
-    'For more information, see the [AI Fabrix Builder documentation](../../docs/README.md).'
-  ];
-
-  return lines.join('\n');
-}
-
-/**
- * Splits a deployment JSON file into component files
- * @async
- * @function splitDeployJson
- * @param {string} deployJsonPath - Path to deployment JSON file
- * @param {string} [outputDir] - Directory to write component files (defaults to same directory as JSON)
- * @returns {Promise<Object>} Object with paths to generated files
- * @throws {Error} If JSON file not found or invalid
- */
 /**
  * Validates deployment JSON path
  * @function validateDeployJsonPath
@@ -396,8 +158,8 @@ async function writeComponentFiles(outputDir, envTemplate, variables, rbac, read
   await writeComponentFile(envTemplatePath, envTemplate);
   results.envTemplate = envTemplatePath;
 
-  // Write variables.yaml
-  const variablesPath = path.join(outputDir, 'variables.yaml');
+  // Write application.yaml
+  const variablesPath = path.join(outputDir, 'application.yaml');
   const variablesYaml = yaml.dump(variables, { indent: 2, lineWidth: -1 });
   await writeComponentFile(variablesPath, variablesYaml);
   results.variables = variablesPath;
@@ -418,18 +180,96 @@ async function writeComponentFiles(outputDir, envTemplate, variables, rbac, read
   return results;
 }
 
+/**
+ * Writes external system and datasource YAML files when deployment has system (external format).
+ * @async
+ * @param {string} outputDir - Output directory
+ * @param {Object} deployment - Deployment with system and dataSources
+ * @returns {Promise<{ systemFile?: string, datasourceFiles?: string[] }>} Paths to written files
+ */
+async function writeExternalSystemAndDatasourceFiles(outputDir, deployment) {
+  if (!deployment || !deployment.system) {
+    return {};
+  }
+  const system = deployment.system;
+  const systemKey = system.key || 'external-system';
+  const dataSourcesList = deployment.dataSources || deployment.datasources || [];
+  const results = {};
+
+  const systemPath = path.join(outputDir, `${systemKey}-system.yaml`);
+  const systemYaml = yaml.dump(system, { indent: 2, lineWidth: -1 });
+  await writeComponentFile(systemPath, systemYaml);
+  results.systemFile = systemPath;
+
+  const datasourcePaths = [];
+  for (let i = 0; i < dataSourcesList.length; i++) {
+    const ds = dataSourcesList[i];
+    const fileName = getExternalDatasourceFileName(systemKey, ds, i);
+    const dsPath = path.join(outputDir, fileName);
+    const dsYaml = yaml.dump(ds, { indent: 2, lineWidth: -1 });
+    await writeComponentFile(dsPath, dsYaml);
+    datasourcePaths.push(dsPath);
+  }
+  results.datasourceFiles = datasourcePaths;
+
+  return results;
+}
+
+/**
+ * Normalizes deployment for split: for external format (deployment.system),
+ * lifts configuration and roles/permissions to top level so extractors work.
+ * @param {Object} deployment - Raw deployment object
+ * @returns {Object} Deployment (mutated) with configuration/roles/permissions at top level when from system
+ */
+function normalizeDeploymentForSplit(deployment) {
+  if (!deployment || !deployment.system) {
+    return deployment;
+  }
+  const system = deployment.system;
+  if (system.configuration && !deployment.configuration) {
+    deployment.configuration = system.configuration;
+  }
+  if (system.roles && !deployment.roles) {
+    deployment.roles = system.roles;
+  }
+  if (system.permissions && !deployment.permissions) {
+    deployment.permissions = system.permissions;
+  }
+  return deployment;
+}
+
+/**
+ * Splits a deployment JSON file into component files.
+ * @async
+ * @function splitDeployJson
+ * @param {string} deployJsonPath - Path to deployment JSON file
+ * @param {string} [outputDir] - Directory to write component files (defaults to same directory as JSON)
+ * @returns {Promise<Object>} Object with paths to generated files
+ * @throws {Error} If JSON file not found or invalid
+ */
 async function splitDeployJson(deployJsonPath, outputDir = null) {
   validateDeployJsonPath(deployJsonPath);
   const finalOutputDir = await prepareOutputDirectory(deployJsonPath, outputDir);
   const deployment = await loadDeploymentJson(deployJsonPath);
+  normalizeDeploymentForSplit(deployment);
 
-  // Extract components
-  const envTemplate = extractEnvTemplate(deployment.configuration || []);
+  const configArray = deployment.configuration || [];
+  const envTemplate = extractEnvTemplate(configArray);
   const variables = extractVariablesYaml(deployment);
   const rbac = extractRbacYaml(deployment);
   const readme = generateReadmeFromDeployJson(deployment);
 
-  return await writeComponentFiles(finalOutputDir, envTemplate, variables, rbac, readme);
+  const result = await writeComponentFiles(finalOutputDir, envTemplate, variables, rbac, readme);
+
+  if (deployment.system && typeof deployment.system === 'object') {
+    const externalFiles = await writeExternalSystemAndDatasourceFiles(finalOutputDir, deployment);
+    if (externalFiles.systemFile) result.systemFile = externalFiles.systemFile;
+    if (externalFiles.datasourceFiles && externalFiles.datasourceFiles.length > 0) {
+      result.datasourceFiles = externalFiles.datasourceFiles;
+    }
+  }
+
+  return result;
 }
 
 module.exports = {