@aifabrix/builder 2.39.2 → 2.40.0

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 = {

package/lib/generator/wizard.js

@@ -6,10 +6,11 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const yaml = require('js-yaml');
 const Handlebars = require('handlebars');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
+const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { generateExternalReadmeContent } = require('../utils/external-readme');
 
 /**
@@ -39,30 +40,30 @@ function toKeySegment(str) {
 /**
  * Writes system JSON file
  * @async
- * @function writeSystemJsonFile
+ * @function writeSystemYamlFile
  * @param {string} appPath - Application path
  * @param {string} finalSystemKey - Final system key
  * @param {Object} systemConfig - System configuration
  * @returns {Promise<string>} System file path
  */
-async function writeSystemJsonFile(appPath, finalSystemKey, systemConfig) {
-  const systemFileName = `${finalSystemKey}-system.json`;
+async function writeSystemYamlFile(appPath, finalSystemKey, systemConfig) {
+  const systemFileName = `${finalSystemKey}-system.yaml`;
   const systemFilePath = path.join(appPath, systemFileName);
-  await fs.writeFile(systemFilePath, JSON.stringify(systemConfig, null, 2), 'utf8');
+  writeConfigFile(systemFilePath, systemConfig);
   logger.log(chalk.green(`✓ Generated system file: ${systemFileName}`));
   return systemFilePath;
 }
 
 /**
- * Writes datasource JSON files
+ * Writes datasource YAML files
  * @async
- * @function writeDatasourceJsonFiles
+ * @function writeDatasourceYamlFiles
  * @param {string} appPath - Application path
  * @param {string} finalSystemKey - Final system key
  * @param {Object[]} datasourceConfigs - Array of datasource configurations
  * @returns {Promise<string[]>} Array of datasource file names
  */
-async function writeDatasourceJsonFiles(appPath, finalSystemKey, datasourceConfigs) {
+async function writeDatasourceYamlFiles(appPath, finalSystemKey, datasourceConfigs) {
   const datasourceFileNames = [];
   for (const datasourceConfig of datasourceConfigs) {
     const entityType = datasourceConfig.entityType || datasourceConfig.entityKey || datasourceConfig.key?.split('-').pop() || 'default';
@@ -72,9 +73,9 @@ async function writeDatasourceJsonFiles(appPath, finalSystemKey, datasourceConfi
     const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${finalSystemKey}-`)
       ? datasourceKey.substring(finalSystemKey.length + 1)
       : keySegment;
-    const datasourceFileName = `${finalSystemKey}-datasource-${datasourceKeyOnly}.json`;
+    const datasourceFileName = `${finalSystemKey}-datasource-${datasourceKeyOnly}.yaml`;
     const datasourceFilePath = path.join(appPath, datasourceFileName);
-    await fs.writeFile(datasourceFilePath, JSON.stringify(datasourceConfig, null, 2), 'utf8');
+    writeConfigFile(datasourceFilePath, datasourceConfig);
     datasourceFileNames.push(datasourceFileName);
     logger.log(chalk.green(`✓ Generated datasource file: ${datasourceFileName}`));
   }
@@ -99,8 +100,8 @@ async function writeDatasourceJsonFiles(appPath, finalSystemKey, datasourceConfi
 async function generateConfigFilesForWizard(params) {
   const { appPath, appName, finalSystemKey, systemFileName, datasourceFileNames, systemConfig, datasourceConfigs, aiGeneratedReadme } = params;
 
-  // Generate or update variables.yaml with externalIntegration block
-  await generateOrUpdateVariablesYaml({
+  // Generate or update application.yaml with externalIntegration block
+  const configPath = await generateOrUpdateVariablesYaml({
     appPath,
     appName,
     systemKey: finalSystemKey,
@@ -126,7 +127,7 @@ async function generateConfigFilesForWizard(params) {
   logger.log(chalk.green(`✓ Generated deployment manifest: ${finalSystemKey}-deploy.json`));
 
   return {
-    variablesPath: path.join(appPath, 'variables.yaml'),
+    variablesPath: configPath,
     envTemplatePath: path.join(appPath, 'env.template'),
     readmePath: path.join(appPath, 'README.md'),
     applicationSchemaPath: deployManifestPath,
@@ -134,48 +135,28 @@ async function generateConfigFilesForWizard(params) {
   };
 }
 
+async function prepareWizardContext(appName, systemConfig, datasourceConfigs) {
+  const appPath = path.join(process.cwd(), 'integration', appName);
+  await fs.mkdir(appPath, { recursive: true });
+  const finalSystemKey = appName;
+  const appDisplayName = appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+  const updatedSystemConfig = { ...systemConfig, key: finalSystemKey, displayName: appDisplayName };
+  const updatedDatasourceConfigs = datasourceConfigs.map(ds => {
+    const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || 'default';
+    const keySegment = toKeySegment(entityType);
+    const entityDisplayName = entityType.charAt(0).toUpperCase() + entityType.slice(1).replace(/-/g, ' ');
+    return { ...ds, key: `${finalSystemKey}-${keySegment}`, systemKey: finalSystemKey, displayName: `${appDisplayName} ${entityDisplayName}` };
+  });
+  return { appPath, finalSystemKey, updatedSystemConfig, updatedDatasourceConfigs, appDisplayName };
+}
+
 async function generateWizardFiles(appName, systemConfig, datasourceConfigs, systemKey, options = {}) {
   try {
     const { aiGeneratedReadme } = options || {};
-    // Determine app path (integration directory for external systems)
-    const appPath = path.join(process.cwd(), 'integration', appName);
-
-    // Create directory if it doesn't exist
-    await fs.mkdir(appPath, { recursive: true });
-
-    // Use appName as the system key to ensure consistent naming
-    // Priority: appName > systemKey parameter > systemConfig.key
-    const finalSystemKey = appName;
-
-    // Generate displayName from appName (e.g., "my-hubspot" -> "My Hubspot")
-    const appDisplayName = appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
-
-    // Update system config to use the appName as key and displayName
-    const updatedSystemConfig = {
-      ...systemConfig,
-      key: finalSystemKey,
-      displayName: appDisplayName
-    };
-
-    // Update datasource configs to use appName-based keys and systemKey (key must match ^[a-z0-9-]+$)
-    const updatedDatasourceConfigs = datasourceConfigs.map(ds => {
-      const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || 'default';
-      const keySegment = toKeySegment(entityType);
-      const entityDisplayName = entityType.charAt(0).toUpperCase() + entityType.slice(1).replace(/-/g, ' ');
-      return {
-        ...ds,
-        key: `${finalSystemKey}-${keySegment}`,
-        systemKey: finalSystemKey,
-        displayName: `${appDisplayName} ${entityDisplayName}`
-      };
-    });
-
-    // Write system and datasource JSON files
-    const systemFilePath = await writeSystemJsonFile(appPath, finalSystemKey, updatedSystemConfig);
-    const datasourceFileNames = await writeDatasourceJsonFiles(appPath, finalSystemKey, updatedDatasourceConfigs);
-
-    // Generate configuration files
-    const systemFileName = `${finalSystemKey}-system.json`;
+    const { appPath, finalSystemKey, updatedSystemConfig, updatedDatasourceConfigs } = await prepareWizardContext(appName, systemConfig, datasourceConfigs);
+    const systemFilePath = await writeSystemYamlFile(appPath, finalSystemKey, updatedSystemConfig);
+    const datasourceFileNames = await writeDatasourceYamlFiles(appPath, finalSystemKey, updatedDatasourceConfigs);
+    const systemFileName = `${finalSystemKey}-system.yaml`;
     const configFiles = await generateConfigFilesForWizard({
       appPath,
       appName,
@@ -186,7 +167,6 @@ async function generateWizardFiles(appName, systemConfig, datasourceConfigs, sys
       datasourceConfigs: updatedDatasourceConfigs,
       aiGeneratedReadme
     });
-
     return {
       appPath,
       systemFilePath,
@@ -199,7 +179,7 @@ async function generateWizardFiles(appName, systemConfig, datasourceConfigs, sys
 }
 
 /**
- * Generate or update variables.yaml with externalIntegration block
+ * Generate or update application.yaml with externalIntegration block
  * @async
  * @function generateOrUpdateVariablesYaml
  * @param {Object} params - Parameters object
@@ -209,23 +189,19 @@ async function generateWizardFiles(appName, systemConfig, datasourceConfigs, sys
  * @param {string} params.systemFileName - System file name
  * @param {string[]} params.datasourceFileNames - Array of datasource file names
  * @param {Object} params.systemConfig - System configuration
+ * @returns {Promise<string>} Path to application config file
  * @throws {Error} If generation fails
  */
 async function generateOrUpdateVariablesYaml(params) {
   const { appPath, appName, systemFileName, datasourceFileNames, systemConfig } = params;
+  let configPath;
+  let variables = {};
   try {
-    const variablesPath = path.join(appPath, 'variables.yaml');
-    let variables = {};
-
-    // Try to read existing variables.yaml
     try {
-      const existingContent = await fs.readFile(variablesPath, 'utf8');
-      variables = yaml.load(existingContent) || {};
-    } catch (error) {
-      // File doesn't exist, create new one
-      if (error.code !== 'ENOENT') {
-        throw error;
-      }
+      configPath = resolveApplicationConfigPath(appPath);
+      variables = loadConfigFile(configPath) || {};
+    } catch {
+      configPath = path.join(appPath, 'application.yaml');
     }
 
     // Set basic app info if not present
@@ -258,10 +234,11 @@ async function generateOrUpdateVariablesYaml(params) {
       version: systemConfig.version || '1.0.0'
     };
 
-    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }), 'utf8');
-    logger.log(chalk.green('✓ Generated/updated variables.yaml'));
+    writeConfigFile(configPath, variables);
+    logger.log(chalk.green('✓ Generated/updated application.yaml'));
+    return configPath;
   } catch (error) {
-    throw new Error(`Failed to generate variables.yaml: ${error.message}`);
+    throw new Error(`Failed to generate application config: ${error.message}`);
   }
 }
 
@@ -445,7 +422,7 @@ async function generateReadme(appPath, appName, systemKey, systemConfig, datasou
       return {
         entityType,
         displayName: ds.displayName || ds.name || ds.key || `Datasource ${index + 1}`,
-        fileName: `${systemKey}-datasource-${datasourceKeyOnly}.json`
+        fileName: `${systemKey}-datasource-${datasourceKeyOnly}.yaml`
       };
     });
 

package/lib/schema/application-schema.json

@@ -799,19 +799,19 @@
         },
         "systems": {
           "type": "array",
-          "description": "List of external-system JSON files to deploy via pipeline.",
+          "description": "List of external-system files to deploy via pipeline (.json, .yaml, or .yml).",
           "items": {
             "type": "string",
-            "pattern": "^[^ ].+\\.json$"
+            "pattern": "^[^ ].+\\.(json|yaml|yml)$"
           },
           "uniqueItems": true
         },
         "dataSources": {
           "type": "array",
-          "description": "List of external-datasource JSON files belonging to this app.",
+          "description": "List of external-datasource files belonging to this app (.json, .yaml, or .yml).",
           "items": {
             "type": "string",
-            "pattern": "^[^ ].+\\.json$"
+            "pattern": "^[^ ].+\\.(json|yaml|yml)$"
           },
           "uniqueItems": true
         },

package/lib/schema/deployment-rules.yaml

@@ -49,7 +49,6 @@ application:
   overridablePaths:
     - configuration.items.value
     - authentication.endpoints
-    - deployment.controllerUrl
     - healthCheck.interval
     - healthCheck.probeIntervalInSeconds
 
@@ -60,7 +59,6 @@ externalSystem:
     - description
     - type
     - enabled
-    - environment
     - authentication
     - openapi
     - mcp
@@ -75,8 +73,6 @@ externalSystem:
     - generateMcpContract
     - generateOpenApiContract
   overridablePaths:
-    - environment.baseUrl
-    - environment.region
     - authentication.oauth2
     - authentication.apikey
     - authentication.basic

package/lib/schema/external-datasource.schema.json

@@ -1587,6 +1587,11 @@
            }
         },
         "additionalProperties":false
+     },
+     "triggerPathsHash":{
+        "type":"string",
+        "description":"SHA256 hash of triggerPaths payload (64-char hex). Used to detect structural changes. Optional; Dataplane computes when absent.",
+        "pattern":"^[a-f0-9]{64}$"
      }
   },
   "additionalProperties":false

package/lib/schema/external-system.schema.json

@@ -102,6 +102,11 @@
       "type": "boolean",
       "default": true
     },
+    "internal": {
+      "type": "boolean",
+      "description": "When true, this integration is deployed on dataplane startup (internal integration). When false or absent, deployed via pipeline only.",
+      "default": false
+    },
     "authentication": {
       "type": "object",
       "description": "Authentication configuration for external system",
@@ -414,6 +419,11 @@
       "type": "boolean",
       "description": "Reserved: whether to generate or expose OpenAPI contract on publish. Not yet implemented.",
       "default": true
+    },
+    "triggerPathsHash": {
+      "type": "string",
+      "description": "SHA256 hash of triggerPaths payload (64-char hex). Used to detect structural changes. Optional; Dataplane computes when absent.",
+      "pattern": "^[a-f0-9]{64}$"
     }
   },
   "additionalProperties": false