@aifabrix/builder 2.44.3 → 2.44.4

package/lib/utils/schema-resolver.js

@@ -175,6 +175,96 @@ function resolveDatasourceFiles(schemaBasePath, datasourceFiles) {
   return datasourceFiles.map(fileName => resolveSingleExternalFile(schemaBasePath, fileName, 'datasource'));
 }
 
+/**
+ * @param {string} schemaBasePath
+ * @param {string[]} systemFileNames
+ * @returns {string[]|null}
+ */
+function readSystemDatasourceKeyOrder(schemaBasePath, systemFileNames) {
+  if (!Array.isArray(systemFileNames) || systemFileNames.length === 0) {
+    return null;
+  }
+  const systemPath = path.join(schemaBasePath, systemFileNames[0]);
+  if (!fs.existsSync(systemPath)) {
+    return null;
+  }
+  try {
+    const systemParsed = loadConfigFile(systemPath);
+    const orderKeys = Array.isArray(systemParsed.dataSources) ? systemParsed.dataSources : null;
+    return orderKeys && orderKeys.length > 0 ? orderKeys : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} schemaBasePath
+ * @param {string[]} datasourceFileNames
+ * @returns {Map<string, string>}
+ */
+function mapDatasourceKeysToFilenames(schemaBasePath, datasourceFileNames) {
+  const byKey = new Map();
+  for (const fileName of datasourceFileNames) {
+    if (typeof fileName !== 'string') {
+      continue;
+    }
+    const fp = path.join(schemaBasePath, fileName);
+    if (!fs.existsSync(fp)) {
+      continue;
+    }
+    try {
+      const d = loadConfigFile(fp);
+      const k = d && typeof d.key === 'string' ? d.key.trim() : '';
+      if (k) {
+        byKey.set(k, fileName);
+      }
+    } catch {
+      /* tail via original list */
+    }
+  }
+  return byKey;
+}
+
+/**
+ * Reorder datasource filenames to match external system JSON `dataSources` key order when present.
+ * Keeps application.yaml list membership but fixes FK-safe sequencing when filenames were sorted or drifted.
+ *
+ * @param {string} schemaBasePath
+ * @param {string[]} systemFileNames - externalIntegration.systems
+ * @param {string[]} datasourceFileNames - externalIntegration.dataSources filenames
+ * @returns {string[]} Same filenames, system-declaration order first, then any leftovers in original order
+ */
+function orderDatasourceFileNamesBySystemKeys(
+  schemaBasePath,
+  systemFileNames,
+  datasourceFileNames
+) {
+  if (!Array.isArray(datasourceFileNames) || datasourceFileNames.length <= 1) {
+    return datasourceFileNames;
+  }
+  const orderKeys = readSystemDatasourceKeyOrder(schemaBasePath, systemFileNames);
+  if (!orderKeys) {
+    return datasourceFileNames;
+  }
+  const byKey = mapDatasourceKeysToFilenames(schemaBasePath, datasourceFileNames);
+  const out = [];
+  const used = new Set();
+  for (const k of orderKeys) {
+    const ks = typeof k === 'string' ? k.trim() : '';
+    const f = ks ? byKey.get(ks) : null;
+    if (f && !used.has(f)) {
+      out.push(f);
+      used.add(f);
+    }
+  }
+  for (const fileName of datasourceFileNames) {
+    if (fileName && !used.has(fileName)) {
+      out.push(fileName);
+    }
+  }
+  return out.length ? out : datasourceFileNames;
+}
+
 /**
  * Loads and validates application config
  * @async
@@ -206,13 +296,19 @@ async function resolveExternalFiles(appName, options = {}) {
 
   const schemaBasePath = await resolveSchemaBasePath(appName, options);
   const systemFiles = resolveSystemFiles(schemaBasePath, variables.externalIntegration.systems);
-  const datasourceFiles = resolveDatasourceFiles(schemaBasePath, variables.externalIntegration.dataSources);
+  const orderedNames = orderDatasourceFileNamesBySystemKeys(
+    schemaBasePath,
+    variables.externalIntegration.systems,
+    variables.externalIntegration.dataSources || []
+  );
+  const datasourceFiles = resolveDatasourceFiles(schemaBasePath, orderedNames);
 
   return [...systemFiles, ...datasourceFiles];
 }
 
 module.exports = {
   resolveSchemaBasePath,
-  resolveExternalFiles
+  resolveExternalFiles,
+  orderDatasourceFileNamesBySystemKeys
 };
 

package/lib/utils/validation-run-poll.js

@@ -8,16 +8,25 @@ const chalk = require('chalk');
 const logger = require('./logger');
 const { getValidationRunWithTransportRetry } = require('./validation-run-post-retry');
 
-const INITIAL_INTERVAL_MS = 2000;
+/** Short fixed delay while waiting for async E2E (typically a few seconds). */
+const FAST_POLL_COUNT = 24;
+const FAST_POLL_INTERVAL_MS = 400;
+/** After fast phase, exponential backoff to limit load on long runs. */
+const SLOW_BASE_INTERVAL_MS = 2000;
 const MAX_INTERVAL_MS = 15000;
 
 /**
- * Delay between polls after attempt `n` (0-based): 2s, 4s, 8s, … cap 15s.
+ * Delay between polls after attempt `n` (0-based).
+ * Fast phase (~10s of 400ms gaps) so CLI detects completion quickly; then 2s, 4s, … cap 15s.
  * @param {number} attemptIndex - Zero-based poll index after initial POST
  * @returns {number}
  */
 function nextPollDelayMs(attemptIndex) {
-  const raw = INITIAL_INTERVAL_MS * 2 ** Math.max(0, attemptIndex);
+  if (attemptIndex < FAST_POLL_COUNT) {
+    return FAST_POLL_INTERVAL_MS;
+  }
+  const slowIndex = attemptIndex - FAST_POLL_COUNT;
+  const raw = SLOW_BASE_INTERVAL_MS * 2 ** Math.max(0, slowIndex);
   return Math.min(raw, MAX_INTERVAL_MS);
 }
 
@@ -104,7 +113,9 @@ async function pollValidationRunUntilComplete(opts) {
 }
 
 module.exports = {
-  INITIAL_INTERVAL_MS,
+  FAST_POLL_COUNT,
+  FAST_POLL_INTERVAL_MS,
+  SLOW_BASE_INTERVAL_MS,
   MAX_INTERVAL_MS,
   nextPollDelayMs,
   pollValidationRunUntilComplete,

package/lib/utils/validation-run-request.js

@@ -36,9 +36,8 @@ function assignOptionalNonNegativeInt(e2e, key, raw) {
  * @param {Object} options - CLI-derived options
  * @param {boolean} [options.debug]
  * @param {boolean} [options.verbose]
- * @param {boolean} [options.testCrud]
- * @param {string} [options.recordId]
  * @param {boolean} [options.cleanup]
+ * @param {boolean} [options.runScenarios] - false when --no-run-scenarios
  * @param {string|Object} [options.primaryKeyValue]
  * @param {Object} [options.e2eOptionsExtra] - Shallow-merged last (e.g. server-specific drill-down fields)
  * @returns {Object}
@@ -47,15 +46,14 @@ function buildE2eOptionsFromCli(options = {}) {
   const e2e = {};
   if (options.debug) e2e.includeDebug = true;
   if (options.verbose) e2e.audit = true;
-  if (options.testCrud === true) e2e.testCrud = true;
-  if (options.recordId !== undefined && options.recordId !== null && options.recordId !== '') {
-    e2e.recordId = String(options.recordId);
-  }
   if (options.cleanup === false) e2e.cleanup = false;
   else if (options.cleanup === true) e2e.cleanup = true;
   if (options.primaryKeyValue !== undefined && options.primaryKeyValue !== null) {
     e2e.primaryKeyValue = options.primaryKeyValue;
   }
+  if (options.runScenarios === false) {
+    e2e.runScenarios = false;
+  }
   assignOptionalNonNegativeInt(e2e, 'minVectorHits', options.minVectorHits);
   assignOptionalNonNegativeInt(e2e, 'minProcessed', options.minProcessed);
   assignOptionalNonNegativeInt(e2e, 'minRecordCount', options.minRecordCount);

package/lib/validation/dimension-display-helpers.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Flatten datasource root `dimensions` for validate CLI output.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+/**
+ * @param {Array<{ fk?: string, dimension?: string }>} via - dimensionBinding.via
+ * @returns {string}
+ */
+function formatFkViaChain(via) {
+  return via
+    .map(v =>
+      v && typeof v.fk === 'string' && typeof v.dimension === 'string' ? `${v.fk}→${v.dimension}` : ''
+    )
+    .filter(Boolean)
+    .join(', ');
+}
+
+/**
+ * @param {unknown} actor - dimensionBinding.actor
+ * @returns {string}
+ */
+function formatFkActorSuffix(actor) {
+  return typeof actor === 'string' && actor.length > 0 ? ` (actor: ${actor})` : '';
+}
+
+/**
+ * Flatten root dimensions: local → metadata.<field>, fk → fk:<chain> (actor: ...).
+ * @param {Record<string, unknown>|null|undefined} root - datasource.dimensions
+ * @returns {Record<string, string>}
+ */
+function flattenRootDimensionsForDisplay(root) {
+  const rootFlat = {};
+  if (!root || typeof root !== 'object' || Array.isArray(root)) {
+    return rootFlat;
+  }
+  for (const [dimKey, binding] of Object.entries(root)) {
+    if (!binding || typeof binding !== 'object') {
+      continue;
+    }
+    if (typeof binding.field === 'string') {
+      rootFlat[dimKey] = `metadata.${binding.field}`;
+      continue;
+    }
+    if (binding.type !== 'fk' || !Array.isArray(binding.via)) {
+      continue;
+    }
+    const chain = formatFkViaChain(binding.via);
+    if (!chain) {
+      continue;
+    }
+    rootFlat[dimKey] = `fk:${chain}${formatFkActorSuffix(binding.actor)}`;
+  }
+  return rootFlat;
+}
+
+module.exports = {
+  flattenRootDimensionsForDisplay
+};

package/lib/validation/validate-display-log-helpers.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Shared log helpers for validate-display (layout.md tty-summary).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { sectionTitle, metadata, successGlyph } = require('../utils/cli-test-layout-chalk');
+
+function logSectionTitle(title) {
+  logger.log(`\n${sectionTitle(title)}`);
+}
+
+function logOkRowRest(message) {
+  logger.log(`  ${successGlyph()} ${chalk.white(message)}`);
+}
+
+function logWarnRow(message) {
+  logger.log(`  ${chalk.yellow('⚠')} ${chalk.white(message)}`);
+}
+
+function logDimLine(text) {
+  logger.log(metadata(`    ${text}`));
+}
+
+function logErrorDetail(message) {
+  logger.log(`    ${chalk.red(`• ${message}`)}`);
+}
+
+module.exports = {
+  logSectionTitle,
+  logOkRowRest,
+  logWarnRow,
+  logDimLine,
+  logErrorDetail
+};