@aifabrix/builder 2.44.3 → 2.44.5

package/lib/datasource/datasource-validate-display.js

@@ -0,0 +1,162 @@
+/**
+ * @fileoverview TTY output for `aifabrix datasource validate` (cli-test-layout-chalk).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const {
+  sectionTitle,
+  headerKeyValue,
+  metadata,
+  formatSuccessLine,
+  formatBlockingError,
+  successGlyph,
+  failureGlyph
+} = require('../utils/cli-test-layout-chalk');
+
+function logSubOk(whitePart, grayPart) {
+  if (grayPart) {
+    logger.log(`  ${successGlyph()} ${chalk.white(whitePart)} ${metadata(grayPart)}`);
+  } else {
+    logger.log(`  ${successGlyph()} ${chalk.white(whitePart)}`);
+  }
+}
+
+function logHeaderAndIdentity(result, trimmed, showMapping) {
+  const { resolvedPath, summary } = result;
+  logger.log('');
+  logger.log(sectionTitle('Datasource validation'));
+  logger.log(metadata('Offline — JSON schema and integration wiring'));
+  logger.log('');
+  if (summary) {
+    logger.log(`  ${headerKeyValue('Key:', summary.key)}`);
+    logger.log(`  ${headerKeyValue('Resource type:', summary.resourceType)}`);
+    logger.log(`  ${headerKeyValue('Entity type:', summary.entityType)}`);
+    logger.log(`  ${headerKeyValue('File:', resolvedPath)}`);
+    if (showMapping && trimmed && String(trimmed) !== String(summary.key)) {
+      logger.log(`  ${headerKeyValue('CLI input:', trimmed)}`);
+    }
+    logger.log('');
+  } else {
+    logger.log(`  ${headerKeyValue('File:', resolvedPath)}`);
+    logger.log('');
+  }
+}
+
+function logInvalidBody(errors, warnings) {
+  logger.log(`  ${formatBlockingError('Datasource file has errors')}`);
+  (errors || []).forEach(err => {
+    logger.log(`    ${failureGlyph()} ${chalk.red(err)}`);
+  });
+  if (warnings && warnings.length > 0) {
+    logger.log('');
+    logger.log(sectionTitle('Warnings'));
+    warnings.forEach(w => {
+      logger.log(`  ${chalk.yellow('⚠')} ${chalk.white(w)}`);
+    });
+  }
+}
+
+function logValidMappingsAndRelations(summary) {
+  const mc = summary.metadataSchemaPropertyCount;
+  const mcLabel = `${mc} propert${mc === 1 ? 'y' : 'ies'}`;
+  logSubOk('Metadata schema', mcLabel);
+  logSubOk('Field mappings', `${summary.fieldMappingAttributeCount} attribute(s)`);
+  logger.log('');
+  logSubOk(`Primary key: ${summary.primaryKey}`);
+  logSubOk(`Label key: ${summary.labelKey}`);
+  logger.log('');
+  if (summary.foreignKeys.length > 0) {
+    logSubOk('Foreign keys', `${summary.foreignKeys.length} reference(s)`);
+    summary.foreignKeys.forEach(fk => {
+      logger.log(metadata(`    • ${fk.name} → ${fk.target} (${fk.fields})`));
+    });
+  } else {
+    logSubOk('Foreign keys', 'none');
+  }
+  logger.log('');
+  if (summary.dimensionKeys.length > 0) {
+    logSubOk('Dimensions (ABAC)', '');
+    summary.dimensionKeys.forEach(k => {
+      logger.log(metadata(`    ${k} → ${summary.dimensions[k]}`));
+    });
+  } else {
+    logSubOk('Dimensions (ABAC)', 'none configured');
+  }
+  logger.log('');
+}
+
+function logOpenapiSection(summary) {
+  if (summary.hasOpenapi) {
+    logSubOk('OpenAPI', summary.openapiLine);
+    if (summary.capabilityKeys.length > 0) {
+      const preview = summary.capabilityKeys.slice(0, 12).join(', ');
+      const more = summary.capabilityKeys.length > 12 ? ', …' : '';
+      logger.log(metadata(`    Operations: ${preview}${more}`));
+    }
+    return;
+  }
+  logSubOk('OpenAPI', 'not configured');
+}
+
+function logValidInterfaceAndFooter(summary) {
+  if (summary.exposedProfileNames.length > 0) {
+    logSubOk('Exposed profiles', summary.exposedProfileNames.join(', '));
+  } else {
+    logSubOk('Exposed profiles', 'none');
+  }
+  logger.log('');
+  logOpenapiSection(summary);
+  logger.log('');
+  logSubOk('Test payload', summary.testPayloadLine);
+  logger.log('');
+  logSubOk('Synchronization', summary.syncLine);
+  logger.log('');
+  const caps = summary.capabilityKeys;
+  const capHint =
+    caps.length > 0 ? `${caps.slice(0, 8).join(', ')}${caps.length > 8 ? ', …' : ''}` : 'none (no OpenAPI operations)';
+  logSubOk('Capabilities', capHint);
+  logger.log('');
+  logger.log(`  ${formatSuccessLine('Datasource file is valid.')}`);
+}
+
+function logWarningsOnly(warnings) {
+  if (!warnings || warnings.length === 0) {
+    return;
+  }
+  logger.log('');
+  logger.log(sectionTitle('Warnings'));
+  warnings.forEach(w => {
+    logger.log(`  ${chalk.yellow('⚠')} ${chalk.white(w)}`);
+  });
+}
+
+/**
+ * @param {object} result - validateDatasourceFile result (includes optional summary)
+ * @param {string} trimmed - CLI argument
+ * @param {boolean} showMapping - true when key resolved to a different path than arg
+ */
+function logDatasourceValidateOutcome(result, trimmed, showMapping) {
+  logHeaderAndIdentity(result, trimmed, showMapping);
+  const { valid, errors, warnings, summary } = result;
+  if (!valid) {
+    logInvalidBody(errors, warnings);
+    return;
+  }
+  if (!summary) {
+    logger.log(`  ${formatSuccessLine('Datasource file is valid.')}`);
+    logWarningsOnly(warnings);
+    return;
+  }
+  logValidMappingsAndRelations(summary);
+  logValidInterfaceAndFooter(summary);
+  logWarningsOnly(warnings);
+}
+
+module.exports = {
+  logDatasourceValidateOutcome
+};

package/lib/datasource/datasource-validate-summary.js

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview Extract display summary from parsed external-datasource JSON (offline validate).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { flattenRootDimensionsForDisplay } = require('../validation/dimension-display-helpers');
+
+/**
+ * Count JSON Schema property nodes (recursive `properties` bags).
+ * @param {object|null|undefined} metadataSchema
+ * @returns {number}
+ */
+function countMetadataSchemaProperties(metadataSchema) {
+  if (!metadataSchema || typeof metadataSchema !== 'object') {
+    return 0;
+  }
+  let n = 0;
+  function walk(node, depth) {
+    if (depth > 25 || !node || typeof node !== 'object') {
+      return;
+    }
+    const props = node.properties;
+    if (props && typeof props === 'object' && !Array.isArray(props)) {
+      for (const key of Object.keys(props)) {
+        n += 1;
+        walk(props[key], depth + 1);
+      }
+    }
+    if (Array.isArray(node.allOf)) {
+      for (const sub of node.allOf) {
+        walk(sub, depth + 1);
+      }
+    }
+    if (node.items && typeof node.items === 'object') {
+      walk(node.items, depth + 1);
+    }
+  }
+  walk(metadataSchema, 0);
+  return n;
+}
+
+/**
+ * @param {object} fk
+ * @returns {{ name: string, target: string, fields: string }}
+ */
+function normalizeForeignKeyRow(fk) {
+  return {
+    name: fk.name,
+    target: fk.targetDatasource,
+    fields: Array.isArray(fk.fields) ? fk.fields.join(', ') : ''
+  };
+}
+
+/**
+ * @param {object} parsed
+ * @returns {{ dimensionKeys: string[], dimensions: Record<string, string> }}
+ */
+function summarizeDimensions(parsed) {
+  const dimFlat = flattenRootDimensionsForDisplay(parsed.dimensions);
+  const abacDims =
+    parsed.abac && parsed.abac.dimensions && typeof parsed.abac.dimensions === 'object' ? parsed.abac.dimensions : {};
+  const allDims = { ...dimFlat, ...abacDims };
+  return { dimensionKeys: Object.keys(allDims), dimensions: allDims };
+}
+
+/**
+ * @param {object|null} sync
+ * @returns {string}
+ */
+function summarizeSyncLine(sync) {
+  if (!sync || typeof sync !== 'object') {
+    return 'Not configured';
+  }
+  const parts = [];
+  if (sync.mode) {
+    parts.push(String(sync.mode));
+  }
+  if (sync.batchSize !== undefined && sync.batchSize !== null) {
+    parts.push(`batch size ${sync.batchSize}`);
+  }
+  if (sync.schedule) {
+    parts.push(`schedule ${JSON.stringify(sync.schedule)}`);
+  }
+  return parts.length ? parts.join(', ') : 'Present';
+}
+
+/**
+ * @param {object} parsed
+ * @returns {{ openapiLine: string, hasOpenapi: boolean, capabilityKeys: string[] }}
+ */
+function summarizeOpenapi(parsed) {
+  const openapi = parsed.openapi && typeof parsed.openapi === 'object' ? parsed.openapi : {};
+  const operations = openapi.operations && typeof openapi.operations === 'object' ? openapi.operations : {};
+  const capabilityKeys = Object.keys(operations);
+  let openapiLine = 'Not configured';
+  if (openapi.enabled === true) {
+    openapiLine = openapi.autoRbac ? 'enabled, auto RBAC' : 'enabled';
+  } else if (parsed.openapi && Object.prototype.hasOwnProperty.call(parsed.openapi, 'enabled')) {
+    openapiLine = 'disabled';
+  }
+  return {
+    openapiLine,
+    hasOpenapi: Object.keys(openapi).length > 0,
+    capabilityKeys
+  };
+}
+
+/**
+ * @param {object} parsed
+ * @returns {string}
+ */
+function summarizeTestPayloadLine(parsed) {
+  const tp = parsed.testPayload;
+  const hasTestPayload = !!tp && typeof tp === 'object';
+  if (!hasTestPayload) {
+    return 'Not configured';
+  }
+  if (Array.isArray(tp.scenarios)) {
+    return `${tp.scenarios.length} scenario(s)`;
+  }
+  return 'Present';
+}
+
+/**
+ * @param {object} parsed
+ * @returns {string[]}
+ */
+function summarizeExposedProfileNames(parsed) {
+  if (parsed.exposed && parsed.exposed.profiles && typeof parsed.exposed.profiles === 'object') {
+    return Object.keys(parsed.exposed.profiles);
+  }
+  return [];
+}
+
+/**
+ * @param {string|undefined} v
+ * @returns {string}
+ */
+function dash(v) {
+  return v || '—';
+}
+
+/**
+ * @param {object} parsed
+ * @returns {object}
+ */
+function assembleSummary(parsed) {
+  const attrs = parsed.fieldMappings && parsed.fieldMappings.attributes;
+  const attrCount = attrs && typeof attrs === 'object' ? Object.keys(attrs).length : 0;
+  const pk = Array.isArray(parsed.primaryKey) ? parsed.primaryKey.join(', ') : String(parsed.primaryKey || '');
+  const lk = Array.isArray(parsed.labelKey) ? parsed.labelKey.join(', ') : String(parsed.labelKey || '');
+  const fks = Array.isArray(parsed.foreignKeys) ? parsed.foreignKeys.map(normalizeForeignKeyRow) : [];
+  const { dimensionKeys, dimensions } = summarizeDimensions(parsed);
+  const oa = summarizeOpenapi(parsed);
+  const sync = parsed.sync && typeof parsed.sync === 'object' ? parsed.sync : null;
+  return {
+    key: dash(parsed.key),
+    resourceType: dash(parsed.resourceType),
+    entityType: dash(parsed.entityType),
+    metadataSchemaPropertyCount: countMetadataSchemaProperties(parsed.metadataSchema),
+    fieldMappingAttributeCount: attrCount,
+    primaryKey: pk || '—',
+    labelKey: lk || '—',
+    foreignKeys: fks,
+    dimensionKeys,
+    dimensions,
+    exposedProfileNames: summarizeExposedProfileNames(parsed),
+    openapiLine: oa.openapiLine,
+    hasOpenapi: oa.hasOpenapi,
+    capabilityKeys: oa.capabilityKeys,
+    testPayloadLine: summarizeTestPayloadLine(parsed),
+    hasTestPayload: !!parsed.testPayload && typeof parsed.testPayload === 'object',
+    syncLine: summarizeSyncLine(sync)
+  };
+}
+
+/**
+ * @param {object} parsed - Parsed datasource JSON
+ * @returns {object|null}
+ */
+function buildDatasourceValidateSummary(parsed) {
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+  return assembleSummary(parsed);
+}
+
+module.exports = {
+  buildDatasourceValidateSummary,
+  countMetadataSchemaProperties
+};

package/lib/datasource/test-e2e.js

@@ -33,9 +33,8 @@ function buildUnifiedE2eRunOptions(options, timeoutMs, pk) {
     verbose: options.verbose,
     async: options.async !== false,
     noAsync: options.async === false,
-    testCrud: options.testCrud,
-    recordId: options.recordId,
     cleanup: options.cleanup,
+    runScenarios: options.runScenarios,
     primaryKeyValue: pk,
     minVectorHits: options.minVectorHits,
     minProcessed: options.minProcessed,
@@ -72,6 +71,59 @@ function e2eIntegrationLogDir(appKey) {
   return path.dirname(getIntegrationPath(appKey));
 }
 
+/**
+ * @param {Object} options
+ * @returns {number}
+ */
+function resolveE2ePollTimeoutMs(options) {
+  const raw =
+    options.timeout !== undefined && options.timeout !== null && options.timeout !== ''
+      ? parseInt(String(options.timeout), 10)
+      : options.pollTimeoutMs;
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_POLL_TIMEOUT_MS;
+}
+
+/**
+ * @param {string} datasourceKey
+ * @param {Object} options
+ * @param {string|Object|null} pk
+ * @returns {Object}
+ */
+function buildE2eRequestMeta(datasourceKey, options, pk) {
+  return {
+    datasourceKey,
+    runType: 'e2e',
+    includeDebug: includeDebugForRequest(options.debug),
+    cleanup: options.cleanup,
+    runScenarios: options.runScenarios,
+    primaryKeyValue: pk !== undefined && pk !== null,
+    minVectorHits: options.minVectorHits,
+    minProcessed: options.minProcessed,
+    minRecordCount: options.minRecordCount
+  };
+}
+
+/**
+ * Write JSON debug log and print paths + CLI wall clock when --debug.
+ * @param {string} appKey
+ * @param {Object} requestMeta
+ * @param {Object} envelope
+ * @param {number} cliWallSeconds
+ * @returns {Promise<void>}
+ */
+async function logE2eDebugSuccess(appKey, requestMeta, envelope, cliWallSeconds) {
+  const logPath = await writeTestLog(
+    appKey,
+    { request: { ...requestMeta, cliWallSeconds }, response: envelope },
+    'test-e2e',
+    e2eIntegrationLogDir(appKey)
+  );
+  logger.log(chalk.gray(`  Debug log: ${logPath}`));
+  logger.log(
+    chalk.gray(`  CLI wall time: ${cliWallSeconds}s (URL resolve, POST, poll, log write)`)
+  );
+}
+
 /**
  * Throw when unified run failed, timed out, or needs async; optionally write debug log.
  * @returns {Promise<void>}
@@ -112,42 +164,19 @@ async function throwIfUnifiedE2EBlocked(unifiedResult, appKey, options, requestM
 }
 
 /**
- * Run E2E test for one datasource (unified validation API; deployment auth like test-integration).
- * @async
- * @param {string} datasourceKey
- * @param {Object} options
- * @param {boolean} [options.sync] - Publish local datasource JSON before validation when true
- * @returns {Promise<Object>} Shape compatible with displayE2EResults (steps, success, status)
+ * Run E2E for one datasource (unified validation API).
+ * @returns {Promise<Object>} displayE2EResults-compatible shape
  */
 async function runDatasourceTestE2E(datasourceKey, options = {}) {
   if (!datasourceKey || typeof datasourceKey !== 'string') {
     throw new Error('Datasource key is required');
   }
+  const cliWallStartedAt = Date.now();
   const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
-
   logE2eDatasourceBanner(datasourceKey, options.verbose);
-
   const pk = await resolvePrimaryKeyValue(options.primaryKeyValue);
-  const timeoutRaw =
-    options.timeout !== undefined && options.timeout !== null && options.timeout !== ''
-      ? parseInt(String(options.timeout), 10)
-      : options.pollTimeoutMs;
-  const timeoutMs =
-    Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? timeoutRaw : DEFAULT_POLL_TIMEOUT_MS;
-
-  const requestMeta = {
-    datasourceKey,
-    runType: 'e2e',
-    includeDebug: includeDebugForRequest(options.debug),
-    testCrud: options.testCrud,
-    recordId: options.recordId,
-    cleanup: options.cleanup,
-    primaryKeyValue: pk !== undefined && pk !== null,
-    minVectorHits: options.minVectorHits,
-    minProcessed: options.minProcessed,
-    minRecordCount: options.minRecordCount
-  };
-
+  const timeoutMs = resolveE2ePollTimeoutMs(options);
+  const requestMeta = buildE2eRequestMeta(datasourceKey, options, pk);
   const unifiedResult = await runUnifiedDatasourceValidation(
     datasourceKey,
     buildUnifiedE2eRunOptions(options, timeoutMs, pk)
@@ -158,14 +187,13 @@ async function runDatasourceTestE2E(datasourceKey, options = {}) {
   const display = e2eShapeFromEnvelope(unifiedResult.envelope);
   Object.assign(display, { datasourceTestRun: unifiedResult.envelope });
 
+  const cliWallSeconds = Math.round((Date.now() - cliWallStartedAt) / 10) / 100;
+  if (unifiedResult.envelope && typeof unifiedResult.envelope === 'object') {
+    unifiedResult.envelope.cliWallSeconds = cliWallSeconds;
+  }
+
   if (options.debug) {
-    const logPath = await writeTestLog(
-      appKey,
-      { request: requestMeta, response: unifiedResult.envelope },
-      'test-e2e',
-      e2eIntegrationLogDir(appKey)
-    );
-    logger.log(chalk.gray(`  Debug log: ${logPath}`));
+    await logE2eDebugSuccess(appKey, requestMeta, unifiedResult.envelope, cliWallSeconds);
   }
 
   return display;

package/lib/datasource/unified-validation-run-body.js

@@ -42,10 +42,9 @@ async function buildUnifiedValidationBody(params) {
       ? buildE2eOptionsFromCli({
         debug: options.debug,
         verbose: options.verbose,
-        testCrud: options.testCrud,
-        recordId: options.recordId,
         cleanup: options.cleanup,
         primaryKeyValue: options.primaryKeyValue,
+        runScenarios: options.runScenarios,
         minVectorHits: options.minVectorHits,
         minProcessed: options.minProcessed,
         minRecordCount: options.minRecordCount,

package/lib/datasource/validate.js

@@ -15,6 +15,7 @@ const { loadExternalDataSourceSchema } = require('../utils/schema-loader');
 const { formatValidationErrors } = require('../utils/error-formatter');
 const { validateFieldReferences } = require('./field-reference-validator');
 const { validateAbac } = require('./abac-validator');
+const { buildDatasourceValidateSummary } = require('./datasource-validate-summary');
 
 const EXCLUDE_JSON_NAMES = new Set(['application.json', 'rbac.json', 'package.json', 'package-lock.json']);
 
@@ -161,7 +162,8 @@ function resolveValidateInputPath(identifier) {
  * @async
  * @function validateDatasourceFile
  * @param {string} filePathOrKey - Path to the datasource JSON file, or datasource `key` resolved under integration/<app>/
- * @returns {Promise<Object>} Validation result with errors, warnings, and `resolvedPath` (absolute JSON path)
+ * @returns {Promise<Object>} Validation result: `valid`, `errors`, `warnings`, `resolvedPath`, and `summary`
+ *   (from `buildDatasourceValidateSummary` when JSON parses; `null` on JSON syntax errors).
  * @throws {Error} If file cannot be read or parsed
  *
  * @example
@@ -185,19 +187,23 @@ async function validateDatasourceFile(filePathOrKey) {
       valid: false,
       errors: [`Invalid JSON syntax: ${error.message}`],
       warnings: [],
-      resolvedPath: filePath
+      resolvedPath: filePath,
+      summary: null
     };
   }
 
+  const summary = buildDatasourceValidateSummary(parsed);
+
   const validate = loadExternalDataSourceSchema();
   const schemaValid = validate(parsed);
 
   if (!schemaValid) {
     return {
       valid: false,
-      errors: formatValidationErrors(validate.errors),
+      errors: formatValidationErrors(validate.errors, { rootData: parsed, dedupe: true }),
       warnings: [],
-      resolvedPath: filePath
+      resolvedPath: filePath,
+      summary
     };
   }
 
@@ -209,7 +215,8 @@ async function validateDatasourceFile(filePathOrKey) {
       valid: false,
       errors: postSchemaErrors,
       warnings: [],
-      resolvedPath: filePath
+      resolvedPath: filePath,
+      summary
     };
   }
 
@@ -217,7 +224,8 @@ async function validateDatasourceFile(filePathOrKey) {
     valid: true,
     errors: [],
     warnings: [],
-    resolvedPath: filePath
+    resolvedPath: filePath,
+    summary
   };
 }
 

package/lib/external-system/test.js

@@ -154,12 +154,21 @@ async function loadDatasourceFiles(datasourceFiles, schemaBasePath, appPath) {
 async function loadExternalSystemFiles(appName) {
   const { appPath } = await detectAppType(appName);
   const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+  const { orderDatasourceFileNamesBySystemKeys } = require('../utils/schema-resolver');
   const configPath = resolveApplicationConfigPath(appPath);
   const variables = await loadVariablesYamlFile(configPath);
 
   const schemaBasePath = variables.externalIntegration.schemaBasePath || './';
   const systemFiles = variables.externalIntegration.systems || [];
-  const datasourceFiles = variables.externalIntegration.dataSources || [];
+  const rawDatasourceFiles = variables.externalIntegration.dataSources || [];
+  const schemaResolved = path.isAbsolute(schemaBasePath)
+    ? schemaBasePath
+    : path.resolve(appPath, schemaBasePath);
+  const datasourceFiles = orderDatasourceFileNamesBySystemKeys(
+    schemaResolved,
+    systemFiles,
+    rawDatasourceFiles
+  );
 
   const systemJsonFiles = await loadSystemFiles(systemFiles, schemaBasePath, appPath);
   const datasourceJsonFiles = await loadDatasourceFiles(datasourceFiles, schemaBasePath, appPath);
@@ -198,10 +207,10 @@ function validateDatasourceSchema(datasource, systemKey, externalDataSourceSchem
 /**
  * Test datasource with payload template
  * @param {Object} datasource - Datasource configuration
- * @param {boolean} verbose - Show detailed output
+ * @param {boolean} _verbose - Show detailed output (reserved; not used in this path yet)
  * @returns {Object} Test results
  */
-function testDatasourceWithPayload(datasource, verbose) {
+function testDatasourceWithPayload(datasource, _verbose) {
   const errors = [];
   const warnings = [];
 
@@ -223,11 +232,6 @@ function testDatasourceWithPayload(datasource, verbose) {
     warnings.push(...metadataSchemaResults.warnings);
   }
 
-  // Compare with expectedResult if provided
-  if (datasource.testPayload.expectedResult && fieldMappingResults.mappedFields && verbose) {
-    warnings.push('expectedResult validation not yet implemented (requires transformation engine)');
-  }
-
   return {
     fieldMappingResults,
     metadataSchemaResults,

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

@@ -12,6 +12,7 @@
 const path = require('path');
 const { detectAppType } = require('../utils/paths');
 const { resolveApplicationConfigPath, resolveRbacPath } = require('../utils/app-config-resolver');
+const { orderDatasourceFileNamesBySystemKeys } = require('../utils/schema-resolver');
 const { loadSystemFile, loadDatasourceFiles } = require('./external');
 const { loadVariables, loadRbac } = require('./helpers');
 
@@ -124,9 +125,18 @@ async function generateControllerManifest(appName, options = {}) {
   if (systemFiles.length === 0) {
     throw new Error('No system files specified in externalIntegration.systems');
   }
+  const schemaResolved = path.isAbsolute(schemaBasePath)
+    ? schemaBasePath
+    : path.resolve(appPath, schemaBasePath);
+  const rawDatasourceNames = variables.externalIntegration.dataSources || [];
+  const orderedDatasourceNames = orderDatasourceFileNamesBySystemKeys(
+    schemaResolved,
+    systemFiles,
+    rawDatasourceNames
+  );
   const [systemJson, datasourceJsons] = await Promise.all([
     loadSystemWithRbac(appPath, schemaBasePath, systemFiles[0]),
-    loadDatasourceFiles(appPath, schemaBasePath, variables.externalIntegration.dataSources || [], {
+    loadDatasourceFiles(appPath, schemaBasePath, orderedDatasourceNames, {
       skipMissingDatasourceFiles: options.skipMissingDatasourceFiles
     })
   ]);
@@ -134,7 +144,7 @@ async function generateControllerManifest(appName, options = {}) {
   const externalIntegration = {
     schemaBasePath,
     systems: systemFiles,
-    dataSources: variables.externalIntegration.dataSources || [],
+    dataSources: orderedDatasourceNames,
     autopublish: variables.externalIntegration.autopublish !== false,
     version: appVersion
   };

package/lib/generator/wizard-prompts.js

@@ -324,17 +324,22 @@ async function promptForExistingCredentialInput() {
  * @function promptForUserIntent
  * @returns {Promise<string>} User intent
  */
+const WIZARD_INTENT_MAX_LENGTH = 1000;
+
 async function promptForUserIntent() {
   const { intent } = await inquirer.prompt([
     {
       type: 'input',
       name: 'intent',
-      message: 'Describe your primary use case (any text):',
+      message: `Describe your primary use case (max ${WIZARD_INTENT_MAX_LENGTH} characters):`,
       default: 'general integration',
       validate: (input) => {
         if (!input || typeof input !== 'string' || input.trim().length === 0) {
           return 'Intent is required';
         }
+        if (input.length > WIZARD_INTENT_MAX_LENGTH) {
+          return `Intent must be ${WIZARD_INTENT_MAX_LENGTH} characters or fewer`;
+        }
         return true;
       }
     }
@@ -437,6 +442,7 @@ async function promptForRunWithSavedConfig() {
 const secondary = require('./wizard-prompts-secondary');
 
 module.exports = {
+  WIZARD_INTENT_MAX_LENGTH,
   promptForMode,
   promptForSystemIdOrKey,
   promptForExistingSystem,