@aifabrix/builder 2.41.0 → 2.42.0

package/lib/external-system/generator.js

@@ -19,18 +19,74 @@ const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 
 // Register Handlebars helper for equality check
 handlebars.registerHelper('eq', (a, b) => a === b);
+handlebars.registerHelper('json', (obj) => JSON.stringify(obj));
 
 /**
- * Generates external system JSON file from template
+ * Build authentication object per schema authenticationVariablesByMethod.
+ * Security values use kv://<systemKey>/<key> pattern.
+ * @param {string} systemKey - External system key
+ * @param {string} authType - Auth method (oauth2, aad, apikey, basic, queryParam, oidc, hmac, none)
+ * @returns {{ method: string, variables: Object, security: Object }} Authentication object
+ */
+function buildAuthenticationFromMethod(systemKey, authType) {
+  const kv = (key) => `kv://${systemKey}/${key}`;
+  const method = authType || 'apikey';
+  const base = 'https://api.example.com';
+
+  const authMap = {
+    oauth2: {
+      variables: { baseUrl: base, tokenUrl: `${base}/oauth/token`, authorizationUrl: `${base}/oauth/authorize` },
+      security: { clientId: kv('clientid'), clientSecret: kv('clientsecret') }
+    },
+    aad: {
+      variables: { baseUrl: base, tokenUrl: 'https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token', tenantId: '{tenant-id}' },
+      security: { clientId: kv('clientid'), clientSecret: kv('clientsecret') }
+    },
+    apikey: {
+      variables: { baseUrl: base, headerName: 'X-API-Key' },
+      security: { apiKey: kv('apikey') }
+    },
+    basic: {
+      variables: { baseUrl: base },
+      security: { username: kv('username'), password: kv('password') }
+    },
+    queryParam: {
+      variables: { baseUrl: base, paramName: 'api_key' },
+      security: { paramValue: kv('paramvalue') }
+    },
+    oidc: {
+      variables: { openIdConfigUrl: 'https://example.com/.well-known/openid-configuration', clientId: 'app-id' },
+      security: {}
+    },
+    hmac: {
+      variables: { baseUrl: base, algorithm: 'sha256', signatureHeader: 'X-Signature' },
+      security: { signingSecret: kv('signingsecret') }
+    },
+    none: {
+      variables: {},
+      security: {}
+    }
+  };
+
+  const auth = authMap[method] || authMap.apikey;
+  return { method, variables: auth.variables, security: auth.security };
+}
+
+/** Target extension for format */
+const FORMAT_EXT = { yaml: '.yaml', json: '.json' };
+
+/**
+ * Generates external system file from template
  * @async
  * @function generateExternalSystemTemplate
  * @param {string} appPath - Application directory path
  * @param {string} systemKey - System key
  * @param {Object} config - System configuration
+ * @param {string} [format] - Output format: 'yaml' (default) or 'json'
  * @returns {Promise<string>} Path to generated file
  * @throws {Error} If generation fails
  */
-async function generateExternalSystemTemplate(appPath, systemKey, config) {
+async function generateExternalSystemTemplate(appPath, systemKey, config, format = 'yaml') {
   try {
     const templatePath = path.join(__dirname, '..', '..', 'templates', 'external-system', 'external-system.json.hbs');
     const templateContent = await fs.readFile(templatePath, 'utf8');
@@ -41,13 +97,15 @@ async function generateExternalSystemTemplate(appPath, systemKey, config) {
       groups: role.groups || role.Groups || undefined
     }));
 
+    const authType = config.authType || 'apikey';
+    const authentication = buildAuthenticationFromMethod(systemKey, authType);
+
     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',
-      baseUrl: config.baseUrl || null,
+      authentication,
       roles: roles || null,
       permissions: config.permissions || null
     };
@@ -55,10 +113,9 @@ async function generateExternalSystemTemplate(appPath, systemKey, config) {
     const rendered = template(context);
     const parsed = JSON.parse(rendered);
 
-    // Generate in same folder as application.yaml (new structure)
-    // Use naming: <app-name>-system.yaml
-    const outputPath = path.join(appPath, `${systemKey}-system.yaml`);
-    writeConfigFile(outputPath, parsed);
+    const ext = FORMAT_EXT[format === 'json' ? 'json' : 'yaml'] || '.yaml';
+    const outputPath = path.join(appPath, `${systemKey}-system${ext}`);
+    writeConfigFile(outputPath, parsed, format === 'json' ? 'json' : 'yaml');
 
     return outputPath;
   } catch (error) {
@@ -66,51 +123,104 @@ async function generateExternalSystemTemplate(appPath, systemKey, config) {
   }
 }
 
+/** Schema-valid entityType values (external-datasource.schema.json) */
+const SCHEMA_ENTITY_TYPES = ['recordStorage', 'documentStorage', 'vectorStore', 'messageService', 'none'];
+
+/** Maps resourceType to schema entityType for generation */
+function resourceTypeToSchemaEntityType(resourceType) {
+  return resourceType === 'document' ? 'documentStorage' : 'recordStorage';
+}
+
+/**
+ * Build datasource context object for template rendering
+ * @param {Object} opts - Options
+ * @param {Object} opts.config - Datasource configuration
+ * @param {string} opts.datasourceKey - Datasource key
+ * @param {Object} opts.dimensions - Dimensions map
+ * @param {Object} opts.attributes - Attributes map
+ * @param {string} opts.fullDatasourceKey - Full key including system
+ * @param {string} opts.entityKey - Entity key portion
+ * @param {string} opts.schemaEntityType - Schema entity type
+ * @param {string} opts.resourceType - Resource type
+ * @returns {Object} Handlebars context
+ */
+function buildDatasourceContext({ config, datasourceKey, dimensions, attributes, fullDatasourceKey, entityKey, schemaEntityType, resourceType }) {
+  const displayName = config.datasourceDisplayName || datasourceKey.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+  const description = config.datasourceDescription || `External datasource for ${datasourceKey}`;
+  const primaryKey = Array.isArray(config.primaryKey) && config.primaryKey.length > 0
+    ? config.primaryKey
+    : ['id'];
+  return {
+    fullDatasourceKey,
+    entityKey,
+    datasourceDisplayName: displayName,
+    datasourceDescription: description,
+    systemKey: config.systemKey,
+    schemaEntityType,
+    resourceType,
+    primaryKey,
+    systemType: config.systemType || 'openapi',
+    dimensions: Object.keys(dimensions).length > 0 ? dimensions : null,
+    attributes: Object.keys(attributes).length > 0 ? attributes : null,
+    raw: { id: '{{raw.id}}', name: '{{raw.name}}' }
+  };
+}
+
+/**
+ * Write datasource output in requested format
+ * @param {string} outputPath - Output file path
+ * @param {string} rendered - Rendered template content
+ * @param {string} format - 'yaml' or 'json'
+ * @returns {Promise<void>}
+ */
+async function writeDatasourceOutput(outputPath, rendered, format) {
+  if (format === 'json') {
+    const yaml = require('js-yaml');
+    const parsed = yaml.load(rendered);
+    writeConfigFile(outputPath, parsed, 'json');
+  } else {
+    await fs.writeFile(outputPath, rendered, 'utf8');
+  }
+}
+
 /**
- * Generates external datasource JSON file from template
+ * Generates external datasource file from template with entityType-driven optional commented sections
  * @async
  * @function generateExternalDataSourceTemplate
  * @param {string} appPath - Application directory path
- * @param {string} datasourceKey - Datasource key
+ * @param {string} datasourceKey - Datasource key (e.g. entity1, company)
  * @param {Object} config - Datasource configuration
+ * @param {string} [format] - Output format: 'yaml' (default) or 'json'
  * @returns {Promise<string>} Path to generated file
  * @throws {Error} If generation fails
  */
-async function generateExternalDataSourceTemplate(appPath, datasourceKey, config) {
+async function generateExternalDataSourceTemplate(appPath, datasourceKey, config, format = 'yaml') {
   try {
-    const templatePath = path.join(__dirname, '..', '..', 'templates', 'external-system', 'external-datasource.json.hbs');
+    const templatePath = path.join(__dirname, '..', '..', 'templates', 'external-system', 'external-datasource.yaml.hbs');
     const templateContent = await fs.readFile(templatePath, 'utf8');
     const template = handlebars.compile(templateContent);
 
     const dimensions = config.dimensions || {};
     const attributes = config.attributes || {};
-    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,
-      entityType: config.entityType || datasourceKey.split('-').pop(),
-      resourceType: config.resourceType || 'document',
-      systemType: config.systemType || 'openapi',
-      // Pass non-empty objects so template uses custom block; empty/null so template uses schema-valid defaults
-      dimensions: Object.keys(dimensions).length > 0 ? dimensions : null,
-      attributes: Object.keys(attributes).length > 0 ? attributes : null,
-      // Literal expression strings for default attribute block (schema: pipe-based DSL {{raw.path}})
-      raw: { id: '{{raw.id}}', name: '{{raw.name}}' }
-    };
+    const resourceType = config.resourceType || 'document';
+    const schemaEntityType = SCHEMA_ENTITY_TYPES.includes(config.entityType)
+      ? config.entityType
+      : resourceTypeToSchemaEntityType(resourceType);
 
-    const rendered = template(context);
-    const datasourceConfig = JSON.parse(rendered);
-
-    // Generate in same folder as application.yaml (new structure)
-    // Use naming: <app-name>-datasource-<datasource-key>.yaml
-    // Extract datasource key (remove system key prefix if present)
-    const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${config.systemKey}-`)
+    const prefix = `${config.systemKey}-`;
+    const fullDatasourceKey = datasourceKey.startsWith(prefix) ? datasourceKey : `${prefix}${datasourceKey}`;
+    const entityKey = (datasourceKey.includes('-') && datasourceKey.startsWith(prefix))
       ? datasourceKey.substring(config.systemKey.length + 1)
       : datasourceKey;
-    const outputPath = path.join(appPath, `${config.systemKey}-datasource-${datasourceKeyOnly}.yaml`);
-    writeConfigFile(outputPath, datasourceConfig);
 
+    const context = buildDatasourceContext({
+      config, datasourceKey, dimensions, attributes, fullDatasourceKey, entityKey, schemaEntityType, resourceType
+    });
+    const rendered = template(context);
+    const ext = FORMAT_EXT[format === 'json' ? 'json' : 'yaml'] || '.yaml';
+    const outputPath = path.join(appPath, `${config.systemKey}-datasource-${entityKey}${ext}`);
+
+    await writeDatasourceOutput(outputPath, rendered, format);
     return outputPath;
   } catch (error) {
     throw new Error(`Failed to generate external datasource template: ${error.message}`);
@@ -124,47 +234,51 @@ async function generateExternalDataSourceTemplate(appPath, datasourceKey, config
  * @param {string} appPath - Application directory path
  * @param {string} appName - Application name
  * @param {Object} config - Configuration with external system details
+ * @param {string} [format] - Output format: 'yaml' (default) or 'json'
  * @returns {Promise<Object>} Object with system and datasource file paths
  * @throws {Error} If generation fails
  */
-async function generateExternalSystemFiles(appPath, appName, config) {
+async function generateExternalSystemFiles(appPath, appName, config, format = 'yaml') {
   try {
     const systemKey = config.systemKey || appName;
     const datasourceCount = config.datasourceCount || 1;
+    const fmt = (format === 'json' ? 'json' : 'yaml');
 
-    // Generate external system JSON
-    const systemPath = await generateExternalSystemTemplate(appPath, systemKey, config);
+    // Generate external system file
+    const systemPath = await generateExternalSystemTemplate(appPath, systemKey, config, fmt);
     logger.log(chalk.green(`✓ Generated external system: ${path.basename(systemPath)}`));
 
     // Generate datasource JSON files
     const datasourcePaths = [];
     const resourceTypes = ['customer', 'contact', 'person', 'document', 'deal'];
 
+    const schemaEntityType = SCHEMA_ENTITY_TYPES.includes(config.entityType)
+      ? config.entityType
+      : 'recordStorage';
+
     for (let i = 0; i < datasourceCount; i++) {
-      const entityType = `entity${i + 1}`;
-      // For datasource key, use just the entity type (will be prefixed with app-name-deploy-)
-      const datasourceKey = entityType;
+      const entityKey = `entity${i + 1}`;
+      const datasourceKey = entityKey;
       const resourceType = resourceTypes[i % resourceTypes.length];
 
       const datasourceConfig = {
         systemKey: systemKey,
-        entityType: entityType,
+        entityType: schemaEntityType,
         resourceType: resourceType,
         systemType: config.systemType || 'openapi',
-        datasourceDisplayName: `${config.systemDisplayName || systemKey} ${entityType}`,
-        datasourceDescription: `External datasource for ${entityType} entity`,
+        datasourceDisplayName: `${config.systemDisplayName || systemKey} ${entityKey}`,
+        datasourceDescription: `External datasource for ${entityKey} entity`,
         dimensions: config.dimensions || {},
         attributes: config.attributes || {}
       };
 
-      // Generate with new naming: <app-name>-datasource-<entity-key>.json
-      const datasourcePath = await generateExternalDataSourceTemplate(appPath, datasourceKey, datasourceConfig);
+      const datasourcePath = await generateExternalDataSourceTemplate(appPath, datasourceKey, datasourceConfig, fmt);
       datasourcePaths.push(datasourcePath);
       logger.log(chalk.green(`✓ Generated datasource: ${path.basename(datasourcePath)}`));
     }
 
-    // Update application.yaml with externalIntegration block
-    await updateVariablesYamlWithExternalIntegration(appPath, systemKey, datasourcePaths);
+    // Update application config with externalIntegration block
+    await updateVariablesYamlWithExternalIntegration(appPath, systemKey, datasourcePaths, fmt);
 
     return {
       systemPath,
@@ -176,36 +290,70 @@ async function generateExternalSystemFiles(appPath, appName, config) {
 }
 
 /**
- * Updates application.yaml with externalIntegration block
+ * Resolve application config path and load variables
+ * @param {string} appPath - Application directory path
+ * @param {string} ext - Config file extension
+ * @returns {{ configPath: string, variables: Object }}
+ */
+function resolveConfigAndVariables(appPath, ext) {
+  try {
+    const configPath = resolveApplicationConfigPath(appPath);
+    const variables = loadConfigFile(configPath) || {};
+    return { configPath, variables };
+  } catch (resolveErr) {
+    const msg = (resolveErr && resolveErr.message) || '';
+    const isNotFound = msg.includes('Config file not found') || msg.includes('Application config not found');
+    if (!isNotFound) throw resolveErr;
+    return { configPath: path.join(appPath, `application${ext}`), variables: {} };
+  }
+}
+
+/**
+ * Remove old config file if it differs from target path
+ * @param {string} configPath - Current config path
+ * @param {string} targetPath - Target output path
+ */
+function maybeRemoveOldConfig(configPath, targetPath) {
+  const same = configPath === targetPath || path.normalize(configPath) === path.normalize(targetPath);
+  if (same) return;
+  const fsSync = require('fs');
+  if (fsSync.existsSync(configPath)) fsSync.unlinkSync(configPath);
+}
+
+/**
+ * Updates application config 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
+ * @param {string} [format] - Output format: 'yaml' (default) or 'json'
  * @throws {Error} If update fails
  */
-async function updateVariablesYamlWithExternalIntegration(appPath, systemKey, datasourcePaths) {
+async function updateVariablesYamlWithExternalIntegration(appPath, systemKey, datasourcePaths, format = 'yaml') {
   try {
-    const configPath = resolveApplicationConfigPath(appPath);
-    const variables = loadConfigFile(configPath);
+    const fmt = format === 'json' ? 'json' : 'yaml';
+    const ext = FORMAT_EXT[fmt] || '.yaml';
+    const { configPath, variables } = resolveConfigAndVariables(appPath, ext);
 
-    // Add externalIntegration block
-    // Files are in same folder, so schemaBasePath is './'
     variables.externalIntegration = {
       schemaBasePath: './',
-      systems: [`${systemKey}-system.yaml`],
+      systems: [`${systemKey}-system${ext}`],
       dataSources: datasourcePaths.map(p => path.basename(p)),
       autopublish: true,
       version: '1.0.0'
     };
 
-    writeConfigFile(configPath, variables);
+    const targetPath = path.join(appPath, `application${ext}`);
+    writeConfigFile(targetPath, variables, fmt);
+    maybeRemoveOldConfig(configPath, targetPath);
   } catch (error) {
     throw new Error(`Failed to update application config: ${error.message}`);
   }
 }
 
 module.exports = {
+  buildAuthenticationFromMethod,
   generateExternalSystemTemplate,
   generateExternalDataSourceTemplate,
   generateExternalSystemFiles

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

@@ -32,7 +32,8 @@ async function executeDatasourceTest(systemKey, datasourceKey, payloadTemplate,
       payloadTemplate,
       dataplaneUrl,
       authConfig,
-      timeout: parseInt(options.timeout, 10) || 30000
+      timeout: parseInt(options.timeout, 10) || 30000,
+      includeDebug: !!options.debug
     });
     return datasourceResult;
   } catch (error) {

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

@@ -0,0 +1,73 @@
+/**
+ * System-level pipeline test - single API call for all datasources
+ * @fileoverview System-level test execution for integration tests
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+/* eslint-disable max-statements,complexity -- Map response to datasource results */
+
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { testSystemViaPipeline } = require('../api/pipeline.api');
+const { writeTestLog } = require('../utils/test-log-writer');
+const { getIntegrationPath } = require('../utils/paths');
+
+/**
+ * Run system-level pipeline test and map response to datasource results
+ * @async
+ * @param {Object} params - Parameters
+ * @param {string} params.appName - Application name
+ * @param {string} params.systemKey - System key
+ * @param {Object} params.authConfig - Auth config
+ * @param {string} params.dataplaneUrl - Dataplane URL
+ * @param {boolean} [params.debug] - Write debug log
+ * @param {number} [params.timeout] - Request timeout
+ * @returns {Promise<{success: boolean, datasourceResults: Object[]}>}
+ */
+async function runSystemLevelTest({ appName, systemKey, authConfig, dataplaneUrl, debug, timeout }) {
+  const testData = { includeDebug: !!debug };
+  const response = await testSystemViaPipeline(dataplaneUrl, systemKey, authConfig, testData, { timeout });
+  const data = response.data || response;
+
+  if (debug) {
+    const appPath = getIntegrationPath(appName);
+    const integrationDir = path.dirname(appPath);
+    const logPath = await writeTestLog(appName, { request: { systemKey, includeDebug: true }, response: data }, 'test-integration', integrationDir);
+    logger.log(chalk.gray(`  Debug log: ${logPath}`));
+  }
+
+  const rawResults = data.datasourceResults || data.results || data.data?.datasourceResults || (Array.isArray(data) ? data : []);
+  const datasourceResults = [];
+  let success = true;
+
+  for (const r of rawResults) {
+    const dsKey = r.key || r.datasourceKey;
+    const dsResult = {
+      key: dsKey,
+      success: r.success !== false,
+      skipped: !!r.skipped,
+      reason: r.reason,
+      validationResults: r.validationResults || {},
+      fieldMappingResults: r.fieldMappingResults || {},
+      endpointTestResults: r.endpointTestResults || {}
+    };
+    if (r.error) dsResult.error = r.error;
+    if (!dsResult.success && !dsResult.skipped) success = false;
+    datasourceResults.push(dsResult);
+  }
+
+  if (rawResults.length === 0 && data.success === false) {
+    success = false;
+    datasourceResults.push({
+      key: 'system',
+      success: false,
+      skipped: false,
+      error: data.error || data.formattedError || 'System test failed'
+    });
+  }
+
+  return { success, datasourceResults };
+}
+
+module.exports = { runSystemLevelTest };

package/lib/external-system/test.js

@@ -1,13 +1,11 @@
 /**
  * External System Testing Module
- *
- * Provides unit testing (local validation) and integration testing (via dataplane)
- * for external systems and datasources.
- *
+ * Provides unit testing (local validation) and integration testing (via dataplane).
  * @fileoverview External system testing functionality for AI Fabrix Builder
  * @author AI Fabrix Team
  * @version 2.0.0
  */
+/* eslint-disable max-lines,max-lines-per-function,max-statements,complexity,max-depth -- Integration test flow with system-level and per-datasource paths */
 
 const fs = require('fs').promises;
 const fsSync = require('fs');
@@ -36,6 +34,7 @@ const {
 const {
   testSingleDatasourceIntegration
 } = require('./test-execution');
+const { runSystemLevelTest } = require('./test-system-level');
 
 /**
  * Loads and parses application config file
@@ -426,22 +425,56 @@ async function testExternalSystemIntegration(appName, options = {}) {
       datasourceResults: []
     };
 
-    // Test each datasource
-    for (const datasourceFile of datasourcesToTest) {
-      const datasourceResult = await testSingleDatasourceIntegration(
-        datasourceFile,
-        systemKey,
-        dataplaneUrl,
-        authConfig,
-        customPayload,
-        options
-      );
-
-      if (!datasourceResult.success && !datasourceResult.skipped) {
-        results.success = false;
+    const useSystemLevel = !options.datasource && datasourcesToTest.length > 0 && !customPayload;
+    const timeout = parseInt(options.timeout, 10) || 30000;
+
+    if (useSystemLevel && datasourcesToTest.length > 1) {
+      try {
+        const systemResult = await runSystemLevelTest({
+          appName, systemKey, authConfig, dataplaneUrl, debug: options.debug, timeout
+        });
+        results.success = systemResult.success;
+        results.datasourceResults = systemResult.datasourceResults;
+      } catch (err) {
+        if (options.debug) {
+          try {
+            const { writeTestLog } = require('../utils/test-log-writer');
+            const { getIntegrationPath } = require('../utils/paths');
+            const appPath = getIntegrationPath(appName);
+            await writeTestLog(appName, { request: { systemKey }, error: err.message }, 'test-integration', path.dirname(appPath));
+          } catch (_) { /* ignore */ }
+        }
+        throw err;
+      }
+    } else {
+      for (const datasourceFile of datasourcesToTest) {
+        const datasourceResult = await testSingleDatasourceIntegration(
+          datasourceFile,
+          systemKey,
+          dataplaneUrl,
+          authConfig,
+          customPayload,
+          options
+        );
+
+        if (!datasourceResult.success && !datasourceResult.skipped) {
+          results.success = false;
+        }
+
+        results.datasourceResults.push(datasourceResult);
       }
 
-      results.datasourceResults.push(datasourceResult);
+      if (options.debug && results.datasourceResults.length > 0) {
+        try {
+          const { writeTestLog } = require('../utils/test-log-writer');
+          const { getIntegrationPath } = require('../utils/paths');
+          const appPath = getIntegrationPath(appName);
+          await writeTestLog(appName, {
+            request: { systemKey, datasource: options.datasource, includeDebug: true },
+            response: results
+          }, 'test-integration', path.dirname(appPath));
+        } catch (_) { /* ignore */ }
+      }
     }
 
     return results;

package/lib/generator/external-controller-manifest.js

@@ -92,6 +92,7 @@ async function loadSystemWithRbac(appPath, schemaBasePath, systemFile) {
  * @param {string} appName - Application name
  * @param {Object} [options] - Optional parameters
  * @param {string} [options.appPath] - Application path (if provided, skips detection)
+ * @param {boolean} [options.skipMissingDatasourceFiles] - If true, skip datasource files that don't exist (e.g. when generating deploy JSON)
  * @returns {Promise<Object>} Controller manifest object
  * @throws {Error} If generation fails
  *
@@ -125,7 +126,9 @@ async function generateControllerManifest(appName, options = {}) {
   }
   const [systemJson, datasourceJsons] = await Promise.all([
     loadSystemWithRbac(appPath, schemaBasePath, systemFiles[0]),
-    loadDatasourceFiles(appPath, schemaBasePath, variables.externalIntegration.dataSources || [])
+    loadDatasourceFiles(appPath, schemaBasePath, variables.externalIntegration.dataSources || [], {
+      skipMissingDatasourceFiles: options.skipMissingDatasourceFiles
+    })
   ]);
   const appVersion = variables.app?.version || variables.externalIntegration?.version || '1.0.0';
   const externalIntegration = {
@@ -150,6 +153,30 @@ async function generateControllerManifest(appName, options = {}) {
   };
 }
 
+/**
+ * Returns deploy-file shape: system + dataSources only (no file-name lists).
+ * Use when writing *-deploy.json to disk; file names live in application config only.
+ *
+ * @function toDeployJsonShape
+ * @param {Object} manifest - Full controller manifest from generateControllerManifest
+ * @returns {Object} { key, displayName, description, type, version, system, dataSources }
+ */
+function toDeployJsonShape(manifest) {
+  if (!manifest || typeof manifest !== 'object') {
+    throw new Error('Manifest is required');
+  }
+  return {
+    key: manifest.key,
+    displayName: manifest.displayName,
+    description: manifest.description,
+    type: manifest.type || 'external',
+    version: manifest.version || '1.0.0',
+    system: manifest.system,
+    dataSources: Array.isArray(manifest.dataSources) ? manifest.dataSources : []
+  };
+}
+
 module.exports = {
-  generateControllerManifest
+  generateControllerManifest,
+  toDeployJsonShape
 };

package/lib/generator/external-schema-utils.js

@@ -192,7 +192,7 @@ async function writeSplitExternalSchemaFiles({ outputDir, systemKey, application
   const rbac = extractRbacYaml(application);
   let rbacPath = null;
   if (rbac) {
-    rbacPath = path.join(outputDir, 'rbac.yml');
+    rbacPath = path.join(outputDir, 'rbac.yaml');
     await writeYamlFile(rbacPath, rbac, { indent: 2, lineWidth: -1 });
   }
 

package/lib/generator/external.js

@@ -174,11 +174,14 @@ async function loadSystemFile(appPath, schemaBasePath, systemFileName) {
  * @param {string} appPath - Application path
  * @param {string} schemaBasePath - Schema base path
  * @param {Array<string>} datasourceFiles - Array of datasource file names
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.skipMissingDatasourceFiles] - If true, skip missing files (e.g. when generating deploy JSON) instead of throwing
  * @returns {Promise<Array<Object>>} Array of datasource JSON objects
- * @throws {Error} If files cannot be loaded
+ * @throws {Error} If a file is missing and skipMissingDatasourceFiles is not set
  */
-async function loadDatasourceFiles(appPath, schemaBasePath, datasourceFiles) {
+async function loadDatasourceFiles(appPath, schemaBasePath, datasourceFiles, options = {}) {
   const datasourceJsons = [];
+  const { skipMissingDatasourceFiles } = options;
 
   for (const datasourceFile of datasourceFiles) {
     const datasourcePath = path.isAbsolute(schemaBasePath)
@@ -186,6 +189,9 @@ async function loadDatasourceFiles(appPath, schemaBasePath, datasourceFiles) {
       : path.join(appPath, schemaBasePath, datasourceFile);
 
     if (!fs.existsSync(datasourcePath)) {
+      if (skipMissingDatasourceFiles) {
+        continue;
+      }
       throw new Error(`Datasource file not found: ${datasourcePath}`);
     }
 
@@ -417,6 +423,7 @@ module.exports = {
   generateExternalSystemApplicationSchema,
   splitExternalApplicationSchema,
   loadSystemFile,
-  loadDatasourceFiles
+  loadDatasourceFiles,
+  loadExternalIntegrationConfig
 };
 

package/lib/generator/index.js

@@ -249,7 +249,10 @@ async function buildDeploymentManifestInMemory(appName, options = {}) {
  * @returns {Promise<string>} Path to written deploy JSON
  */
 async function writeExternalDeployJson(appName, appPath, options) {
-  const manifest = await generateControllerManifest(appName, options);
+  const manifest = await generateControllerManifest(appName, {
+    ...options,
+    skipMissingDatasourceFiles: true
+  });
   let effectivePort = 3000;
   try {
     const variablesPath = resolveApplicationConfigPath(appPath);