@aifabrix/builder 2.42.1 → 2.44.0

package/lib/datasource/log-viewer.js

@@ -0,0 +1,252 @@
+/**
+ * Log viewer for E2E and integration test logs - format and display JSON logs.
+ * @fileoverview Read and format test-e2e / test-integration debug logs for terminal
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+/* eslint-disable max-statements, complexity, max-depth -- Formatter functions; display branches by design */
+
+const path = require('path');
+const fs = require('fs').promises;
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { resolveAppKeyForDatasource } = require('./resolve-app');
+const { getIntegrationPath } = require('../utils/paths');
+const { sectionTitle, headerKeyValue, formatBlockingError, successGlyph, failureGlyph } = require('../utils/cli-test-layout-chalk');
+
+/**
+ * Get the path to the latest log file in a directory matching a glob-like pattern
+ * @param {string} logsDir - Directory containing log files
+ * @param {string} pattern - Prefix pattern (e.g. 'test-e2e' matches test-e2e-*.json)
+ * @returns {Promise<string|null>} Full path to latest file or null if none
+ */
+async function getLatestLogPath(logsDir, pattern) {
+  let entries;
+  try {
+    entries = await fs.readdir(logsDir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+  const prefix = pattern.replace(/\*$/, '');
+  const files = entries
+    .filter(e => e.isFile() && e.name.startsWith(prefix) && e.name.endsWith('.json'))
+    .map(e => path.join(logsDir, e.name));
+  if (files.length === 0) return null;
+  const withStats = await Promise.all(
+    files.map(async f => ({ path: f, mtime: (await fs.stat(f)).mtimeMs }))
+  );
+  withStats.sort((a, b) => b.mtime - a.mtime);
+  return withStats[0].path;
+}
+
+/**
+ * Truncate string for display
+ * @param {string} s - String
+ * @param {number} maxLen - Max length
+ * @returns {string}
+ */
+function truncate(s, maxLen = 60) {
+  if (typeof s !== 'string') return String(s);
+  return s.length <= maxLen ? s : `${s.slice(0, maxLen - 1)}…`;
+}
+
+/**
+ * Format E2E log content for terminal display
+ * @param {Object} data - Parsed log JSON (request, response, error)
+ * @param {string} [fileName] - Log file name for header
+ */
+function logE2ERequestSection(data) {
+  const req = data.request || {};
+  logger.log('');
+  logger.log(sectionTitle('Request:'));
+  logger.log(headerKeyValue('sourceIdOrKey:', String(req.sourceIdOrKey ?? '—')));
+  if (req.includeDebug !== undefined) logger.log(chalk.gray(`  includeDebug: ${req.includeDebug}`));
+  if (req.cleanup !== undefined) logger.log(chalk.gray(`  cleanup: ${req.cleanup}`));
+  if (req.primaryKeyValue !== undefined) {
+    logger.log(chalk.gray(`  primaryKeyValue: ${truncate(JSON.stringify(req.primaryKeyValue))}`));
+  }
+  return req;
+}
+
+function logE2EStepsSection(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) return;
+  logger.log(sectionTitle('Steps:'));
+  for (const step of steps) {
+    const name = step.name || step.step || 'unknown';
+    const ok = step.success !== false && !step.error;
+    logger.log(`  ${ok ? successGlyph() : failureGlyph()} ${chalk.white(name)}`);
+    if (step.error) logger.log(chalk.red(`    ${step.error}`));
+    if (step.message && ok) logger.log(chalk.gray(`    ${step.message}`));
+    if ((name === 'sync' || step.step === 'sync') && step.evidence && step.evidence.jobs) {
+      for (const job of step.evidence.jobs) {
+        const audit = job.audit || {};
+        const parts = [];
+        if (job.recordsProcessed !== undefined && job.recordsProcessed !== null) parts.push(`${job.recordsProcessed} processed`);
+        if (job.totalRecords !== undefined && job.totalRecords !== null) parts.push(`total: ${job.totalRecords}`);
+        if (
+          (audit.inserted !== undefined && audit.inserted !== null) ||
+          (audit.updated !== undefined && audit.updated !== null) ||
+          (audit.deleted !== undefined && audit.deleted !== null)
+        ) {
+          parts.push(`(inserted: ${audit.inserted ?? 0}, updated: ${audit.updated ?? 0}, deleted: ${audit.deleted ?? 0})`);
+        }
+        if (parts.length) logger.log(chalk.gray(`    Job: ${parts.join(' ')}`));
+      }
+    }
+  }
+}
+
+function logE2EAuditTraceSection(req, res) {
+  if (!res.auditLog || !Array.isArray(res.auditLog) || res.auditLog.length === 0) return;
+  logger.log('');
+  logger.log(sectionTitle('CIP execution trace(s):'));
+  logger.log(chalk.gray(`${res.auditLog.length}`));
+  const baseUrl = (req.dataplaneUrl || '').toString().replace(/\/$/, '');
+  const sourceIdOrKey = req.sourceIdOrKey || '';
+  res.auditLog.slice(0, 3).forEach((trace, i) => {
+    const id = trace.executionId || trace.id || trace.traceId;
+    if (!id) return;
+    const idStr = String(id);
+    logger.log(chalk.gray(`  ${i + 1}. executionId: ${idStr}`));
+    if (baseUrl && sourceIdOrKey) {
+      const executionUrl = `${baseUrl}/api/v1/external/${sourceIdOrKey}/executions/${idStr}`;
+      logger.log(chalk.gray(`      Link: ${executionUrl}`));
+    }
+  });
+}
+
+function logE2EResponseSection(req, data) {
+  if (data.error) {
+    logger.log(formatBlockingError(`Error: ${data.error}`));
+    return;
+  }
+  const res = data.response || {};
+  logger.log('');
+  logger.log(sectionTitle('Response:'));
+  logger.log(chalk.gray(`  success: ${res.success}`));
+  if (res.status) logger.log(chalk.gray(`  status: ${res.status}`));
+  if (res.error) logger.log(chalk.red(`  error: ${res.error}`));
+  const steps = res.steps || res.completedActions || [];
+  logE2EStepsSection(steps);
+  logE2EAuditTraceSection(req, res);
+}
+
+function formatE2ELog(data, fileName) {
+  logger.log('');
+  logger.log(sectionTitle('E2E log'));
+  if (fileName) logger.log(chalk.gray(fileName));
+  const req = logE2ERequestSection(data);
+  logE2EResponseSection(req, data);
+}
+
+/**
+ * Format integration test log content for terminal display
+ * @param {Object} data - Parsed log JSON
+ * @param {string} [fileName] - Log file name for header
+ */
+function formatIntegrationLog(data, fileName) {
+  logger.log('');
+  logger.log(sectionTitle('Integration log'));
+  if (fileName) logger.log(chalk.gray(fileName));
+  const req = data.request || {};
+  logger.log('');
+  logger.log(sectionTitle('Request:'));
+  logger.log(chalk.gray(`  systemKey: ${req.systemKey ?? '—'}, datasourceKey: ${req.datasourceKey ?? '—'}`));
+  if (req.includeDebug !== undefined) logger.log(chalk.gray(`  includeDebug: ${req.includeDebug}`));
+  if (data.error) {
+    logger.log(formatBlockingError(`Error: ${data.error}`));
+    return;
+  }
+  const res = data.response || {};
+  logger.log('');
+  logger.log(sectionTitle('Response:'));
+  logger.log(chalk.gray(`  success: ${res.success}`));
+  if (res.error) logger.log(chalk.red(`  error: ${res.error}`));
+  const vr = res.validationResults || {};
+  logger.log(sectionTitle('Validation:'));
+  logger.log(chalk.gray(`  isValid: ${vr.isValid}`));
+  if (vr.errors && vr.errors.length) vr.errors.forEach(e => logger.log(chalk.red(`    - ${e}`)));
+  const fmr = res.fieldMappingResults || {};
+  if (Object.keys(fmr).length) {
+    logger.log(sectionTitle('Field mapping:'));
+    logger.log(chalk.gray(`  mappingCount: ${fmr.mappingCount ?? '—'}`));
+    if (fmr.dimensions) logger.log(chalk.gray(`  dimensions: ${Object.keys(fmr.dimensions).join(', ')}`));
+  }
+  const etr = res.endpointTestResults || {};
+  if (Object.keys(etr).length) {
+    logger.log(sectionTitle('Endpoint:'));
+    logger.log(chalk.gray(`  endpointConfigured: ${etr.endpointConfigured}`));
+  }
+  if (res.normalizedOutput || res.normalizedMetadata) {
+    const out = res.normalizedOutput || res.normalizedMetadata;
+    const keys = typeof out === 'object' && out !== null ? Object.keys(out) : [];
+    logger.log(sectionTitle('Normalized output:') + ' ' + chalk.gray(keys.length ? `${keys.length} fields` : '—'));
+  }
+}
+
+/**
+ * Format log content by type
+ * @param {Object} parsed - Parsed JSON log
+ * @param {'test-e2e'|'test-integration'} logType - Log type
+ * @param {string} [fileName] - File name for header
+ */
+function formatLogContent(parsed, logType, fileName) {
+  if (logType === 'test-e2e') {
+    formatE2ELog(parsed, fileName);
+  } else {
+    formatIntegrationLog(parsed, fileName);
+  }
+}
+
+/**
+ * Run log viewer: resolve log file, read, parse, format and print
+ * @async
+ * @param {string} datasourceKey - Datasource key (used when no --file)
+ * @param {Object} options - Options
+ * @param {string} [options.app] - App key (optional, resolved from key if omitted)
+ * @param {string} [options.file] - Path to log file (overrides app resolution)
+ * @param {'test-e2e'|'test-integration'} options.logType - Log type
+ * @throws {Error} When file not found or invalid JSON
+ */
+/* eslint-disable-next-line max-statements -- Resolve path, read, parse, format */
+async function runLogViewer(datasourceKey, options) {
+  const { app, file, logType } = options;
+  let logPath;
+  let fileName;
+  if (file && typeof file === 'string' && file.trim()) {
+    logPath = path.isAbsolute(file) ? file : path.resolve(process.cwd(), file.trim());
+    fileName = path.basename(logPath);
+  } else {
+    if (!datasourceKey || typeof datasourceKey !== 'string') {
+      throw new Error('Datasource key is required when --file is not provided');
+    }
+    const { appKey } = await resolveAppKeyForDatasource(datasourceKey.trim(), app);
+    const appPath = getIntegrationPath(appKey);
+    const logsDir = path.join(appPath, 'logs');
+    const pattern = logType === 'test-e2e' ? 'test-e2e-' : 'test-integration-';
+    logPath = await getLatestLogPath(logsDir, pattern);
+    if (!logPath) {
+      throw new Error(
+        `No ${logType} log found in ${logsDir}. Run the test with --debug first.`
+      );
+    }
+    fileName = path.basename(logPath);
+  }
+  const content = await fs.readFile(logPath, 'utf8');
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${logPath}: ${err.message}`);
+  }
+  formatLogContent(parsed, logType, fileName);
+}
+
+module.exports = {
+  getLatestLogPath,
+  formatLogContent,
+  formatE2ELog,
+  formatIntegrationLog,
+  runLogViewer
+};

package/lib/datasource/resolve-app.js

@@ -0,0 +1,109 @@
+/**
+ * Resolve app key for datasource commands from explicit --app, cwd, scan, or key parse.
+ * @fileoverview App resolution for datasource test-e2e, test-integration, log-e2e, log-integration
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getIntegrationPath,
+  listIntegrationAppNames,
+  resolveIntegrationAppKeyFromCwd
+} = require('../utils/paths');
+const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+const { loadConfigFile } = require('../utils/config-format');
+
+/**
+ * For one app, check if any of its datasource files has the given key
+ * @param {string} appKey - Integration folder name (system key context)
+ * @param {string} datasourceKey - Datasource key to match
+ * @returns {boolean} True if this app has a datasource with that key
+ */
+function appHasDatasourceKey(appKey, datasourceKey) {
+  const appPath = getIntegrationPath(appKey);
+  let config;
+  try {
+    const configPath = resolveApplicationConfigPath(appPath);
+    config = loadConfigFile(configPath);
+  } catch {
+    return false;
+  }
+  const schemaBasePath = config.externalIntegration?.schemaBasePath || './';
+  const datasourceFiles = config.externalIntegration?.dataSources || [];
+  for (const f of datasourceFiles) {
+    if (!f || typeof f !== 'string') continue;
+    const fullPath = path.isAbsolute(schemaBasePath)
+      ? path.join(schemaBasePath, f)
+      : path.join(appPath, schemaBasePath, f);
+    if (!fs.existsSync(fullPath)) continue;
+    try {
+      const parsed = loadConfigFile(fullPath);
+      if (parsed && parsed.key === datasourceKey) return true;
+    } catch {
+      // skip unreadable or invalid files
+    }
+  }
+  return false;
+}
+
+/**
+ * Resolve app key for a datasource: explicit --app, cwd, scan by key, or parse key convention.
+ * @async
+ * @param {string} datasourceKey - Datasource key (e.g. hubspot-test-company)
+ * @param {string} [explicitApp] - Explicit integration folder from --app
+ * @returns {Promise<{appKey: string}>} Resolved app key
+ * @throws {Error} When app cannot be determined or multiple apps match
+ */
+/* eslint-disable-next-line max-statements -- Resolution order: explicit, cwd, scan, parse */
+async function resolveAppKeyForDatasource(datasourceKey, explicitApp) {
+  if (!datasourceKey || typeof datasourceKey !== 'string') {
+    throw new Error('Datasource key is required');
+  }
+  const key = String(datasourceKey).trim();
+  if (key.length === 0) {
+    throw new Error('Datasource key cannot be empty');
+  }
+
+  if (explicitApp && typeof explicitApp === 'string' && explicitApp.trim()) {
+    const appPath = getIntegrationPath(explicitApp.trim());
+    if (fs.existsSync(appPath)) {
+      return { appKey: explicitApp.trim() };
+    }
+  }
+
+  const fromCwd = resolveIntegrationAppKeyFromCwd();
+  if (fromCwd && appHasDatasourceKey(fromCwd, key)) {
+    return { appKey: fromCwd };
+  }
+
+  const appNames = listIntegrationAppNames();
+  const matches = appNames.filter(appName => appHasDatasourceKey(appName, key));
+  if (matches.length === 1) {
+    return { appKey: matches[0] };
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `More than one app has this datasource; add --app <app>. Apps: ${matches.join(', ')}`
+    );
+  }
+
+  const segments = key.split('-');
+  if (segments.length >= 2) {
+    const candidate = segments.slice(0, -1).join('-');
+    const candidatePath = getIntegrationPath(candidate);
+    if (fs.existsSync(candidatePath) && appHasDatasourceKey(candidate, key)) {
+      return { appKey: candidate };
+    }
+  }
+
+  throw new Error(
+    'Could not determine app context. Use --app <app> or run from integration/<systemKey>/ directory.'
+  );
+}
+
+module.exports = {
+  resolveAppKeyForDatasource,
+  appHasDatasourceKey
+};

package/lib/datasource/test-e2e.js

@@ -1,43 +1,34 @@
 /**
- * Datasource E2E test - run full E2E test via dataplane external API
- * @fileoverview Datasource E2E test logic (config, credential, sync, data, CIP)
+ * Datasource E2E test — unified POST /api/v1/validation/run (runType=e2e).
+ * @fileoverview Datasource E2E via DatasourceTestRun envelope
  * @author AI Fabrix Team
  * @version 2.0.0
  */
-/* eslint-disable max-statements -- Auth setup, API call, polling, debug log */
 
 const path = require('path');
 const fs = require('fs').promises;
 const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { getIntegrationPath, resolveIntegrationAppKeyFromCwd } = require('../utils/paths');
-const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
-const { resolveControllerUrl } = require('../utils/controller-url');
-const { getDeviceOnlyAuth } = require('../utils/token-manager');
-const { testDatasourceE2E, getE2ETestRun } = require('../api/external-test.api');
+const { getIntegrationPath } = require('../utils/paths');
+const { resolveAppKeyForDatasource } = require('./resolve-app');
+const { infoLine } = require('../utils/cli-test-layout-chalk');
+const { runUnifiedDatasourceValidation } = require('./unified-validation-run');
+const { includeDebugForRequest } = require('../utils/validation-run-request');
+const { e2eShapeFromEnvelope } = require('../utils/datasource-test-run-legacy-adapter');
 const { writeTestLog } = require('../utils/test-log-writer');
 
-const DEFAULT_POLL_INTERVAL_MS = 2500;
 const DEFAULT_POLL_TIMEOUT_MS = 15 * 60 * 1000;
 
-/**
- * Resolve appKey for datasource test-e2e
- * @param {string} [appKey] - Explicit app key from --app
- * @returns {string}
- */
-function resolveAppKey(appKey) {
-  if (appKey) return appKey;
-  const fromCwd = resolveIntegrationAppKeyFromCwd();
-  if (fromCwd) return fromCwd;
-  throw new Error(
-    'Could not determine app context. Use --app <appKey> or run from integration/<appKey>/ directory.'
-  );
+function logE2eDatasourceBanner(datasourceKey, verbose) {
+  if (!verbose) return;
+  logger.log('');
+  logger.log(infoLine(`🧪 Running E2E test for datasource: ${datasourceKey}`));
 }
 
 /**
  * Resolve primaryKeyValue for request body: string as-is, or read and parse JSON from @path
- * @param {string} [value] - Literal value or path prefixed with @ (e.g. @pk.json)
- * @returns {Promise<string|Object|null>} Resolved value for body.primaryKeyValue, or null if absent
+ * @param {string} [value]
+ * @returns {Promise<string|Object|null>}
  */
 async function resolvePrimaryKeyValue(value) {
   if (value === null || value === undefined || value === '') return null;
@@ -50,170 +41,119 @@ async function resolvePrimaryKeyValue(value) {
   return str;
 }
 
-/**
- * Build E2E request body from options
- * @param {Object} options - Command options
- * @returns {Promise<Object>} Request body
- */
-async function buildE2EBody(options) {
-  const body = {};
-  if (options.debug) body.includeDebug = true;
-  if (options.testCrud === true) body.testCrud = true;
-  if (options.recordId !== undefined && options.recordId !== null && options.recordId !== '') body.recordId = String(options.recordId);
-  if (options.cleanup === false) body.cleanup = false;
-  else if (options.cleanup === true) body.cleanup = true;
-  const pk = await resolvePrimaryKeyValue(options.primaryKeyValue);
-  if (pk !== null && pk !== undefined) body.primaryKeyValue = pk;
-  return body;
+function e2eIntegrationLogDir(appKey) {
+  return path.dirname(getIntegrationPath(appKey));
 }
 
 /**
- * Poll E2E test run until completed or failed
- * @param {string} dataplaneUrl - Dataplane URL
- * @param {string} sourceIdOrKey - Source ID or key
- * @param {string} testRunId - Test run ID
- * @param {Object} authConfig - Auth config
- * @param {Object} opts - Poll options
- * @param {number} [opts.intervalMs] - Poll interval (ms)
- * @param {number} [opts.timeoutMs] - Max wait (ms)
- * @param {boolean} [opts.verbose] - Log each poll
- * @returns {Promise<Object>} Final poll result (status completed or failed)
+ * Throw when unified run failed, timed out, or needs async; optionally write debug log.
+ * @returns {Promise<void>}
  */
-async function pollE2ETestRun(dataplaneUrl, sourceIdOrKey, testRunId, authConfig, opts = {}) {
-  const intervalMs = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
-  const verbose = opts.verbose === true;
-  const deadline = Date.now() + timeoutMs;
-  let last;
-  while (Date.now() < deadline) {
-    last = await getE2ETestRun(dataplaneUrl, sourceIdOrKey, testRunId, authConfig);
-    if (last.status === 'completed' || last.status === 'failed') {
-      return last;
+async function throwIfUnifiedE2EBlocked(unifiedResult, appKey, options, requestMeta) {
+  if (unifiedResult.apiError) {
+    const msg =
+      unifiedResult.apiError.formattedError ||
+      unifiedResult.apiError.error ||
+      'E2E request failed';
+    if (options.debug) {
+      await writeTestLog(
+        appKey,
+        { request: requestMeta, error: msg },
+        'test-e2e',
+        e2eIntegrationLogDir(appKey)
+      );
     }
-    if (verbose) {
-      const steps = last.completedActions || [];
-      logger.log(chalk.gray(`  Polling… status: ${last.status}, ${steps.length} step(s) completed`));
+    throw new Error(msg);
+  }
+  if (unifiedResult.pollTimedOut) {
+    const err = new Error('Report incomplete: timeout');
+    if (options.debug) {
+      await writeTestLog(
+        appKey,
+        { request: requestMeta, error: err.message },
+        'test-e2e',
+        e2eIntegrationLogDir(appKey)
+      );
     }
-    await new Promise(r => setTimeout(r, intervalMs));
+    throw err;
+  }
+  if (unifiedResult.incompleteNoAsync) {
+    throw new Error(
+      'Report incomplete: async polling disabled (--no-async) but server returned partial report.'
+    );
   }
-  throw new Error(
-    `E2E test run did not complete within ${timeoutMs / 1000}s (run ID: ${testRunId})`
-  );
 }
 
 /**
- * Run E2E test for one datasource (Bearer token or API key required; no client credentials).
- * Default: async start + polling until completed/failed. Use options.async === false for sync.
- *
+ * Run E2E test for one datasource (unified validation API; deployment auth like test-integration).
  * @async
- * @param {string} datasourceKey - Datasource key (used as sourceIdOrKey)
- * @param {Object} options - Options
- * @param {string} [options.app] - App key (or resolve from cwd)
- * @param {string} [options.environment] - Environment (dev, tst, pro)
- * @param {boolean} [options.debug] - Include debug, write log file
- * @param {boolean} [options.verbose] - Verbose output (e.g. poll progress)
- * @param {boolean} [options.async] - If false, use sync mode (no polling). Default true.
- * @param {boolean} [options.testCrud] - Set body testCrud true
- * @param {string} [options.recordId] - Set body recordId
- * @param {boolean} [options.cleanup] - Set body cleanup (default true)
- * @param {string} [options.primaryKeyValue] - Set body primaryKeyValue (string or @path to JSON)
- * @param {number} [options.pollIntervalMs] - Poll interval in ms (default 2500)
- * @param {number} [options.pollTimeoutMs] - Poll timeout in ms (default 15 min)
- * @returns {Promise<Object>} E2E test result (steps, success, error, etc.)
+ * @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)
  */
 async function runDatasourceTestE2E(datasourceKey, options = {}) {
   if (!datasourceKey || typeof datasourceKey !== 'string') {
     throw new Error('Datasource key is required');
   }
-  const appKey = resolveAppKey(options.app);
-  const controllerUrl = await resolveControllerUrl();
-  const { resolveEnvironment } = require('../core/config');
-  const environment = options.environment || await resolveEnvironment();
-  const authConfig = await getDeviceOnlyAuth(controllerUrl);
-  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+  const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
 
-  logger.log(chalk.blue(`\n🧪 Running E2E test for datasource: ${datasourceKey}`));
+  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 body = await buildE2EBody(options);
-  const useAsync = options.async !== false;
   const requestMeta = {
-    sourceIdOrKey: datasourceKey,
-    includeDebug: options.debug,
+    datasourceKey,
+    runType: 'e2e',
+    includeDebug: includeDebugForRequest(options.debug),
     testCrud: options.testCrud,
     recordId: options.recordId,
     cleanup: options.cleanup,
-    primaryKeyValue: options.primaryKeyValue !== undefined && options.primaryKeyValue !== null
+    primaryKeyValue: pk !== undefined && pk !== null
   };
 
-  const execOpts = {
-    dataplaneUrl,
-    datasourceKey,
-    authConfig,
-    body,
-    useAsync,
+  const unifiedResult = await runUnifiedDatasourceValidation(datasourceKey, {
+    app: options.app,
+    environment: options.environment,
+    runType: 'e2e',
+    debug: options.debug,
     verbose: options.verbose,
-    pollIntervalMs: options.pollIntervalMs,
-    pollTimeoutMs: options.pollTimeoutMs
-  };
-  let data;
-  try {
-    data = await executeE2EWithOptionalPoll(execOpts);
-  } catch (error) {
-    if (options.debug) {
-      const appPath = getIntegrationPath(appKey);
-      const integrationDir = path.dirname(appPath);
-      await writeTestLog(appKey, { request: requestMeta, error: error.message }, 'test-e2e', integrationDir);
-    }
-    throw error;
-  }
+    async: options.async !== false,
+    noAsync: options.async === false,
+    testCrud: options.testCrud,
+    recordId: options.recordId,
+    cleanup: options.cleanup,
+    primaryKeyValue: pk,
+    capabilityKey: options.capabilityKey,
+    timeout: timeoutMs,
+    sync: options.sync === true
+  });
 
-  if (options.debug) {
-    const appPath = getIntegrationPath(appKey);
-    const integrationDir = path.dirname(appPath);
-    const logPath = await writeTestLog(appKey, { request: requestMeta, response: data }, 'test-e2e', integrationDir);
-    logger.log(chalk.gray(`  Debug log: ${logPath}`));
-  }
+  await throwIfUnifiedE2EBlocked(unifiedResult, appKey, options, requestMeta);
 
-  return data;
-}
+  const display = e2eShapeFromEnvelope(unifiedResult.envelope);
+  Object.assign(display, { datasourceTestRun: unifiedResult.envelope });
 
-/**
- * Call E2E API and optionally poll until completed. On throw, caller should log if debug.
- * @param {Object} opts - Options
- * @param {string} opts.dataplaneUrl - Dataplane URL
- * @param {string} opts.datasourceKey - Source key
- * @param {Object} opts.authConfig - Auth config
- * @param {Object} opts.body - Request body
- * @param {boolean} opts.useAsync - Whether to use async + poll
- * @param {boolean} opts.verbose - Verbose poll progress
- * @param {number} [opts.pollIntervalMs] - Override poll interval (ms)
- * @param {number} [opts.pollTimeoutMs] - Override poll timeout (ms)
- * @returns {Promise<Object>} Final result data
- */
-/* eslint-disable-next-line max-params -- single opts object; destructuring in body */
-async function executeE2EWithOptionalPoll(opts) {
-  const { dataplaneUrl, datasourceKey, authConfig, body, useAsync, verbose, pollIntervalMs, pollTimeoutMs } = opts;
-  const response = await testDatasourceE2E(dataplaneUrl, datasourceKey, authConfig, body, {
-    asyncRun: useAsync
-  });
-  let data = response.data || response;
-  if (useAsync && data !== null && data !== undefined && data.testRunId) {
-    data = await pollE2ETestRun(
-      dataplaneUrl,
-      datasourceKey,
-      data.testRunId,
-      authConfig,
-      {
-        intervalMs: pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
-        timeoutMs: pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS,
-        verbose
-      }
+  if (options.debug) {
+    const logPath = await writeTestLog(
+      appKey,
+      { request: requestMeta, response: unifiedResult.envelope },
+      'test-e2e',
+      e2eIntegrationLogDir(appKey)
     );
+    logger.log(chalk.gray(`  Debug log: ${logPath}`));
   }
-  return data;
+
+  return display;
 }
 
 module.exports = {
   runDatasourceTestE2E,
-  resolveAppKey
+  resolvePrimaryKeyValue
 };