@aifabrix/builder 2.44.3 → 2.44.4

package/lib/commands/datasource.js

@@ -10,10 +10,10 @@
  */
 
 const path = require('path');
-const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { sectionTitle, headerKeyValue, metadata, formatSuccessLine, formatBlockingError } = require('../utils/cli-test-layout-chalk');
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
 const { validateDatasourceFile } = require('../datasource/validate');
+const { logDatasourceValidateOutcome } = require('../datasource/datasource-validate-display');
 const { listDatasources } = require('../datasource/list');
 const { compareDatasources } = require('../datasource/diff');
 const { deployDatasource } = require('../datasource/deploy');
@@ -53,34 +53,6 @@ Examples:
   $ af ds upload ../integration/hubspot/hubspot-datasource-deals.json
 `;
 
-/**
- * TTY layout for local datasource JSON validation (aligned with cli-test-layout-chalk).
- * @param {{ valid: boolean, errors: string[], resolvedPath: string }} result
- * @param {string} trimmed - original CLI argument
- * @param {boolean} showMapping - show Key + File when key resolved to a path
- */
-function logDatasourceValidateOutcome(result, trimmed, showMapping) {
-  logger.log('');
-  logger.log(sectionTitle('Datasource validation'));
-  logger.log(metadata('Offline — JSON schema and integration wiring'));
-  logger.log('');
-  if (!result.valid) {
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-    logger.log('');
-    logger.log(formatBlockingError('Datasource file has errors:'));
-    result.errors.forEach(error => logger.log(chalk.red(`  • ${error}`)));
-    return;
-  }
-  if (showMapping) {
-    logger.log(headerKeyValue('Key:', trimmed));
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-  } else {
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-  }
-  logger.log('');
-  logger.log(formatSuccessLine('Datasource file is valid.'));
-}
-
 function setupDatasourceValidateCommand(datasource) {
   datasource.command('validate <file-or-key>')
     .description('Validate datasource JSON (file path or datasource key under integration/<app>/)')
@@ -97,7 +69,7 @@ function setupDatasourceValidateCommand(datasource) {
           process.exit(1);
         }
       } catch (error) {
-        logger.error(formatBlockingError('Validation failed:'), error.message);
+        logger.error(formatBlockingError(`Validation failed: ${error.message}`));
         process.exit(1);
       }
     });

package/lib/commands/repair-datasource-keys.js

@@ -193,7 +193,7 @@ function normalizeDatasourceKeysAndFilenames(appPath, datasourceFiles, systemKey
   }
 
   if (updated && variables.externalIntegration && Array.isArray(variables.externalIntegration.dataSources)) {
-    variables.externalIntegration.dataSources = [...newDatasourceFiles].sort();
+    variables.externalIntegration.dataSources = [...newDatasourceFiles];
   }
 
   return { updated, datasourceFiles: newDatasourceFiles };

package/lib/commands/repair-datasource-openapi.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Repair OpenAPI block on external datasource JSON.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+function hasNonEmptyObject(v) {
+  return !!v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0;
+}
+
+/**
+ * Repair `openapi` section:
+ * - If operations exist, ensure `openapi.enabled=true`
+ * - If enabled/operations and missing documentKey/fileId, default documentKey to datasource key (common convention)
+ * - If enabled+operations and autoRbac missing, default to true (wizard/fixtures expectation)
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Change log
+ * @returns {boolean} True if updated
+ */
+function repairOpenapiSection(parsed, changes) {
+  const openapi = parsed?.openapi;
+  if (!openapi || typeof openapi !== 'object') {
+    return false;
+  }
+
+  const hasOps = hasNonEmptyObject(openapi.operations);
+  const enabled = openapi.enabled === true;
+  let updated = false;
+
+  if (hasOps && openapi.enabled !== true) {
+    openapi.enabled = true;
+    changes.push('Set openapi.enabled=true (operations present)');
+    updated = true;
+  }
+
+  if ((enabled || hasOps) && !openapi.documentKey && !openapi.fileId) {
+    if (typeof parsed.key === 'string' && parsed.key.trim()) {
+      openapi.documentKey = parsed.key.trim();
+      changes.push(`Set openapi.documentKey=${openapi.documentKey}`);
+      updated = true;
+    }
+  }
+
+  if ((enabled || hasOps) && hasOps && openapi.autoRbac === undefined) {
+    openapi.autoRbac = true;
+    changes.push('Set openapi.autoRbac=true (enabled operations, default)');
+    updated = true;
+  }
+
+  return updated;
+}
+
+module.exports = { repairOpenapiSection };
+

package/lib/commands/repair-datasource.js

@@ -9,6 +9,8 @@
 
 'use strict';
 
+const { repairOpenapiSection } = require('./repair-datasource-openapi');
+
 const DEFAULT_SYNC = {
   mode: 'pull',
   batchSize: 500
@@ -446,6 +448,8 @@ function repairDatasourceFile(parsed, options = {}, changes = []) {
     updated = repairMetadataSchemaFromAttributes(parsed, out) || updated;
   }
 
+  updated = repairOpenapiSection(parsed, out) || updated;
+
   if (options.expose) {
     updated = repairExposeFromAttributes(parsed, out) || updated;
   }
@@ -472,6 +476,7 @@ module.exports = {
   repairExposeFromAttributes,
   repairSyncSection,
   repairTestPayload,
+  repairOpenapiSection,
   sanitizeTestPayloadTopLevel,
   repairDatasourceFile,
   DEFAULT_SYNC,

package/lib/commands/repair-internal.js

@@ -40,7 +40,6 @@ function discoverIntegrationFiles(appPath) {
     }
   }
   systemFiles.sort();
-  datasourceFiles.sort();
   return { systemFiles, datasourceFiles };
 }
 
@@ -48,8 +47,8 @@ function discoverIntegrationFiles(appPath) {
  * Builds the effective datasource file list from application.yaml and discovered files.
  * @param {string} appPath - Application directory path
  * @param {string[]} discoveredDatasourceFiles - Filenames from discoverIntegrationFiles
- * @param {string[]} [existingDataSources] - externalIntegration.dataSources from application.yaml
- * @returns {string[]} Sorted, deduplicated list of datasource filenames
+ * @param {string[]} [existingDataSources] - externalIntegration.dataSources from application config
+ * @returns {string[]} Deduplicated list of datasource filenames (application order first, then remaining discovered files in directory order)
  */
 function buildEffectiveDatasourceFiles(appPath, discoveredDatasourceFiles, existingDataSources) {
   const existing = Array.isArray(existingDataSources) ? existingDataSources : [];
@@ -75,7 +74,6 @@ function buildEffectiveDatasourceFiles(appPath, discoveredDatasourceFiles, exist
       seen.add(name);
     }
   }
-  result.sort();
   return result;
 }
 

package/lib/commands/repair.js

@@ -204,8 +204,7 @@ function alignSystemFileDataSources(appPath, systemParsed, datasourceFiles, syst
       keys.push(deriveDatasourceKeyFromFileName(fileName, systemKey));
     }
   }
-  keys.sort();
-  const prev = Array.isArray(systemParsed.dataSources) ? [...systemParsed.dataSources].sort() : [];
+  const prev = Array.isArray(systemParsed.dataSources) ? [...systemParsed.dataSources] : [];
   if (JSON.stringify(prev) === JSON.stringify(keys)) return false;
   systemParsed.dataSources = keys;
   changes.push(`dataSources: [${prev.join(', ') || '(none)'}] → [${keys.join(', ')}] (keys from each datasource file's "key" or filename)`);

package/lib/commands/test-e2e-external.js

@@ -42,8 +42,8 @@ function deriveDatasourceKeyFromFileName(fileName, systemKey) {
  * @param {Object} variables - Loaded application variables (externalIntegration.dataSources = filenames)
  * @param {string} systemKey - System key from system file
  * @param {Object} systemParsed - Parsed system config (may have dataSources array of keys)
- * @param {string[]} datasourceFiles - Discovered datasource filenames
- * @returns {string[]} Sorted list of datasource keys
+ * @param {string[]} datasourceFiles - Discovered datasource filenames (application order when built via repair)
+ * @returns {string[]} Datasource keys in declaration order (system JSON or file list — never sort; FK targets must run first)
  */
 function getDatasourceKeys(appPath, configPath, variables, systemKey, systemParsed, datasourceFiles) {
   const fromSystem = Array.isArray(systemParsed.dataSources) && systemParsed.dataSources.length > 0
@@ -54,11 +54,11 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
   if (fromSystem) {
     fromSystem.forEach(k => {
       if (k && typeof k === 'string' && !seen.has(k)) {
-        keys.push(k.trim());
-        seen.add(k.trim());
+        const trimmed = k.trim();
+        keys.push(trimmed);
+        seen.add(trimmed);
       }
     });
-    keys.sort();
     return keys;
   }
   for (const fileName of datasourceFiles) {
@@ -81,7 +81,6 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
       }
     }
   }
-  keys.sort();
   return keys;
 }
 

package/lib/commands/upload.js

@@ -17,7 +17,8 @@ const { getIntegrationPath } = require('../utils/paths');
 const { pushCredentialSecrets } = require('../utils/credential-secrets-env');
 const {
   buildResolvedEnvMapForIntegration,
-  resolveConfigurationValues
+  resolveConfigurationValues,
+  collectResolvedVariableConfigurationNames
 } = require('../utils/configuration-env-resolver');
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { displayValidationResults } = require('../validation/validate-display');
@@ -70,9 +71,11 @@ function buildUploadPayload(manifest) {
 /**
  * Resolves dataplane URL and auth (same pattern as download).
  * @param {string} systemKey - System key
+ * @param {{ silent?: boolean }} [opts] - silent: omit “Resolving dataplane URL…” and discovery success lines
  * @returns {Promise<{ dataplaneUrl: string, authConfig: Object, environment: string }>}
  */
-async function resolveDataplaneAndAuth(systemKey) {
+async function resolveDataplaneAndAuth(systemKey, opts = {}) {
+  const silent = opts.silent === true;
   const { resolveEnvironment } = require('../core/config');
   const environment = await resolveEnvironment();
   const controllerUrl = await resolveControllerUrl();
@@ -82,8 +85,10 @@ async function resolveDataplaneAndAuth(systemKey) {
     throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register <systemKey>" first.');
   }
 
-  logger.log(chalk.gray('Resolving dataplane URL...'));
-  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+  if (!silent) {
+    logger.log(chalk.gray('Resolving dataplane URL...'));
+  }
+  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig, { silent });
   return { dataplaneUrl, authConfig, environment };
 }
 
@@ -167,6 +172,15 @@ async function pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey,
   } else {
     logger.log(chalk.yellow('Secret push skipped'));
   }
+  const resolvedParamNames = collectResolvedVariableConfigurationNames(payload);
+  if (resolvedParamNames.length > 0) {
+    const nameList = ` (${resolvedParamNames.join(', ')})`;
+    logger.log(
+      formatSuccessLine(
+        `Resolved ${resolvedParamNames.length} integration parameter(s) from .env for publish${nameList}.`
+      )
+    );
+  }
   if (pushResult.warning) {
     logger.log(chalk.yellow(`Warning: ${pushResult.warning}`));
   }

package/lib/commands/wizard-dataplane.js

@@ -73,10 +73,12 @@ function createDataplaneNotFoundError() {
  * @returns {Promise<string>} Dataplane URL
  * @throws {Error} If dataplane URL cannot be retrieved
  */
-async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig) {
+async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig, silent) {
   try {
     const fallbackUrl = await getDataplaneUrl(controllerUrl, 'dataplane', environment, authConfig);
-    logger.log(formatSuccessLine(`Dataplane URL: ${fallbackUrl}`));
+    if (!silent) {
+      logger.log(formatSuccessLine(`Dataplane URL: ${fallbackUrl}`));
+    }
     return fallbackUrl;
   } catch (fallbackError) {
     if (isNotFoundError(fallbackError)) {
@@ -93,19 +95,25 @@ async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig) {
  * @param {string} controllerUrl - Controller URL
  * @param {string} environment - Environment key
  * @param {Object} authConfig - Authentication configuration
+ * @param {{ silent?: boolean }} [opts] - When silent, skip progress/success lines (e.g. cert sync right after a run).
  * @returns {Promise<string>} Dataplane URL
  * @throws {Error} If dataplane URL cannot be discovered
  */
-async function discoverDataplaneUrl(controllerUrl, environment, authConfig) {
-  logger.log(infoLine('🌐 Getting dataplane URL from controller...'));
+async function discoverDataplaneUrl(controllerUrl, environment, authConfig, opts = {}) {
+  const silent = opts.silent === true;
+  if (!silent) {
+    logger.log(infoLine('🌐 Getting dataplane URL from controller...'));
+  }
   try {
     const dataplaneAppKey = await findDataplaneServiceAppKey(controllerUrl, environment, authConfig);
     if (dataplaneAppKey) {
       const dataplaneUrl = await getDataplaneUrl(controllerUrl, dataplaneAppKey, environment, authConfig);
-      logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
+      if (!silent) {
+        logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
+      }
       return dataplaneUrl;
     }
-    return await tryFallbackDataplaneUrl(controllerUrl, environment, authConfig);
+    return await tryFallbackDataplaneUrl(controllerUrl, environment, authConfig, silent);
   } catch (error) {
     if (error.message.includes('Could not discover dataplane URL')) {
       throw error;

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
+};