@aifabrix/builder 2.54.1 → 2.55.2

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

@@ -25,11 +25,13 @@ const {
 async function runTestTrustForExternalSystem(externalSystem, options = {}) {
   const { systemKey } = resolveExternalIntegrationContext(externalSystem);
 
-  const uploadCtx = await syncLocalIfRequested(systemKey, options);
-  if (uploadCtx?.authConfig && uploadCtx?.dataplaneUrl) {
-    options.authConfig = uploadCtx.authConfig;
-    options.dataplaneUrl = uploadCtx.dataplaneUrl;
-    options.silentResolve = true;
+  if (options.upload === true && options.noPublish !== true) {
+    const uploadCtx = await syncLocalIfRequested(systemKey, options);
+    if (uploadCtx?.authConfig && uploadCtx?.dataplaneUrl) {
+      options.authConfig = uploadCtx.authConfig;
+      options.dataplaneUrl = uploadCtx.dataplaneUrl;
+      options.silentResolve = true;
+    }
   }
   if (options.revalidate === true) {
     logger.log(chalk.cyan('Forcing revalidation (cache bypass)…'));

package/lib/commands/upload-sidecar-followups.js

@@ -117,7 +117,8 @@ async function runUploadSidecarFollowups(ctx) {
     governance: null,
     evidence: null,
     knowledge: null,
-    documentStorageSettings: null
+    documentStorageSettings: null,
+    tests: null
   };
   const quietSidecar = isQuietMinimalSync(ctx.options);
   const model = buildRoleAssistantModel(ctx.payload);
@@ -131,6 +132,8 @@ async function runUploadSidecarFollowups(ctx) {
     throw err;
   }
   await runKnowledgeSidecar(ctx, model, sidecar, quietSidecar);
+  const { runTestsSidecar } = require('../role-assistant/test-pack-sync');
+  await runTestsSidecar(ctx, sidecar, quietSidecar);
   return sidecar;
 }
 

package/lib/commands/verify-governance-command-action.js

@@ -6,6 +6,7 @@
 
 const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { runVerifyGovernanceCombined } = require('./verify-governance-combined-external');
 const { normalizeTestGovernanceCliOptions } = require('./test-governance-cli-options');
 const { displayVerifyGovernanceTTY } = require('../lifecycle/report-display');
@@ -33,16 +34,17 @@ async function runVerifyGovernanceCommandAction(appName, options, cmd) {
   const opts = normalizeVerifyGovernanceCliOptions(options, cmd);
   const result = await runVerifyGovernanceCombined(appName, opts);
 
+  const exitCode = exitCodeFromVerdict(result.verdict);
+
   if (opts.json) {
-    logger.log(JSON.stringify(buildJsonEnvelope(result, opts.verbose), null, 2));
-  } else {
-    if (opts.verbose && !opts.pack && typeof result.generated === 'number' && result.generated > 0) {
-      logger.log(formatSuccessLine(`Generated packs for ${result.generated} datasource(s)`));
-    }
-    displayVerifyGovernanceTTY(result.systemKey, result, { details: opts.verbose });
+    await writeJsonEnvelopeAndExit(buildJsonEnvelope(result, opts.verbose), exitCode);
+    return;
   }
 
-  const exitCode = exitCodeFromVerdict(result.verdict);
+  if (opts.verbose && !opts.pack && typeof result.generated === 'number' && result.generated > 0) {
+    logger.log(formatSuccessLine(`Generated packs for ${result.generated} datasource(s)`));
+  }
+  displayVerifyGovernanceTTY(result.systemKey, result, { details: opts.verbose });
   if (exitCode !== 0) {
     process.exit(exitCode);
   }

package/lib/commands/verify-operations-command-action.js

@@ -6,8 +6,8 @@
 
 'use strict';
 
-const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { cliOptsSkipPublish } = require('../utils/cli-sync-options');
 const { runVerifyOperationsForExternalSystem } = require('./verify-operations-external');
 const { displayVerifyOperationsTTY } = require('../lifecycle/report-display');
@@ -37,16 +37,17 @@ async function runVerifyOperationsCommandAction(appName, options, cmd) {
   const opts = normalizeVerifyOperationsCliOptions(options, cmd);
   const result = await runVerifyOperationsForExternalSystem(appName, opts);
 
+  const exitCode = exitCodeFromVerdict(result.verdict);
+
   if (opts.json) {
-    logger.log(JSON.stringify(buildJsonEnvelope(result, opts.verbose), null, 2));
-  } else {
-    displayVerifyOperationsTTY(appName, result, {
-      details: opts.verbose,
-      warnings: result.warnings
-    });
+    await writeJsonEnvelopeAndExit(buildJsonEnvelope(result, opts.verbose), exitCode);
+    return;
   }
 
-  const exitCode = exitCodeFromVerdict(result.verdict);
+  displayVerifyOperationsTTY(appName, result, {
+    details: opts.verbose,
+    warnings: result.warnings
+  });
   if (exitCode !== 0) {
     process.exit(exitCode);
   }

package/lib/commands/verify-operations-skip-e2e.js

@@ -0,0 +1,131 @@
+/**
+ * When verify-operations should skip live E2E (Role Assistant or static custom).
+ *
+ * @fileoverview Skip E2E for packages that have no live vendor pull
+ */
+
+'use strict';
+
+const path = require('path');
+const { loadConfigFile } = require('../utils/config-format');
+const { discoverIntegrationFiles } = require('./repair-internal');
+
+const STORAGE_ENTITY_TYPES = new Set(['recordStorage', 'documentStorage']);
+
+/**
+ * Role Assistant packages use authType none + nested builder-api CIP.
+ * Live capacity E2E expects a system baseUrl credential and is not the RA certify path.
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {boolean}
+ */
+function shouldSkipE2eForRoleAssistant(systemKey, options) {
+  if (options.forceE2e === true) {
+    return false;
+  }
+  try {
+    const { resolveAppWorkspace } = require('../utils/app-path-resolve');
+    const { baseDir } = resolveAppWorkspace(systemKey, {});
+    return baseDir === 'role-assistant';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Object|null}
+ */
+function readManifestObject(filePath) {
+  try {
+    const parsed = loadConfigFile(filePath);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @returns {string|null}
+ */
+function readLocalSystemType(appPath, systemKey) {
+  const candidates = [
+    path.join(appPath, `${systemKey}-system.json`),
+    path.join(appPath, `${systemKey}-system.yaml`),
+    path.join(appPath, `${systemKey}-system.yml`)
+  ];
+  for (const filePath of candidates) {
+    const doc = readManifestObject(filePath);
+    if (doc && typeof doc.type === 'string' && doc.type.trim()) {
+      return doc.type.trim().toLowerCase();
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {string} appPath
+ * @returns {Object[]}
+ */
+function loadStorageDatasources(appPath) {
+  const { datasourceFiles } = discoverIntegrationFiles(appPath);
+  const storage = [];
+  for (const name of datasourceFiles) {
+    const doc = readManifestObject(path.join(appPath, name));
+    if (!doc || !STORAGE_ENTITY_TYPES.has(String(doc.entityType || ''))) {
+      continue;
+    }
+    storage.push(doc);
+  }
+  return storage;
+}
+
+/**
+ * Static custom packages (syncBridge disabled) have no live vendor pull.
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {boolean}
+ */
+function shouldSkipE2eForStaticPackage(systemKey, options) {
+  if (options.forceE2e === true) {
+    return false;
+  }
+  try {
+    const { resolveAppWorkspace } = require('../utils/app-path-resolve');
+    const { baseDir, appPath } = resolveAppWorkspace(systemKey, options);
+    if (baseDir !== 'integration' || !appPath) {
+      return false;
+    }
+    if (readLocalSystemType(appPath, systemKey) !== 'custom') {
+      return false;
+    }
+    const storage = loadStorageDatasources(appPath);
+    if (storage.length === 0) {
+      return false;
+    }
+    return storage.every((ds) => String(ds.syncBridge || 'disabled').toLowerCase() === 'disabled');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {boolean}
+ */
+function shouldSkipOperationsE2e(systemKey, options) {
+  if (options.skipE2e === true || options.minimal === true) {
+    return true;
+  }
+  return shouldSkipE2eForRoleAssistant(systemKey, options)
+    || shouldSkipE2eForStaticPackage(systemKey, options);
+}
+
+module.exports = {
+  shouldSkipOperationsE2e,
+  shouldSkipE2eForRoleAssistant,
+  shouldSkipE2eForStaticPackage
+};

package/lib/commands/verify-operations-step-plan.js

@@ -7,6 +7,7 @@
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { testExternalSystem, testExternalSystemIntegration } = require('../external-system/test');
 const { runTestE2EForExternalSystem } = require('./test-e2e-external');
+const { shouldSkipOperationsE2e } = require('./verify-operations-skip-e2e');
 
 /**
  * @param {string} systemKey
@@ -59,21 +60,13 @@ function buildAfterSyncSteps(systemKey, options) {
  * @returns {Object}
  */
 function buildE2eStep(systemKey, options) {
-  if (options.skipE2e === true || options.minimal === true) {
+  if (shouldSkipOperationsE2e(systemKey, options)) {
+    const reason = options.skipE2e === true || options.minimal === true
+      ? 'minimal'
+      : 'static-or-role-assistant';
     return {
       key: 'e2e',
-      run: async() => ({ success: true, skipped: true, reason: 'minimal' }),
-      ok: () => true
-    };
-  }
-  if (shouldSkipE2eForRoleAssistant(systemKey, options)) {
-    return {
-      key: 'e2e',
-      run: async() => ({
-        success: true,
-        skipped: true,
-        reason: 'role-assistant-auth-none'
-      }),
+      run: async() => ({ success: true, skipped: true, reason }),
       ok: () => true
     };
   }
@@ -99,26 +92,6 @@ function buildE2eStep(systemKey, options) {
   };
 }
 
-/**
- * Role Assistant packages use authType none + nested builder-api CIP.
- * Live capacity E2E expects a system baseUrl credential and is not the RA certify path.
- * @param {string} systemKey
- * @param {Object} options
- * @returns {boolean}
- */
-function shouldSkipE2eForRoleAssistant(systemKey, options) {
-  if (options.forceE2e === true) {
-    return false;
-  }
-  try {
-    const { resolveAppWorkspace } = require('../utils/app-path-resolve');
-    const { baseDir } = resolveAppWorkspace(systemKey, {});
-    return baseDir === 'role-assistant';
-  } catch {
-    return false;
-  }
-}
-
 /**
  * @param {string} systemKey
  * @param {Object} options

package/lib/commands/verify-operations-steps.js

@@ -86,7 +86,9 @@ async function runOperationsVerifySteps(systemKey, options) {
     }
   }
 
-  if (!cliOptsSkipPublish(options)) {
+  // Upload is not publish. Verify against the already-deployed dataplane unless
+  // the caller opts in with upload: true (and did not pass --no-publish).
+  if (options.upload === true && !cliOptsSkipPublish(options)) {
     const uploadCtx = await syncLocalIfRequested(systemKey, options);
     attachUploadAuthToOptions(options, uploadCtx);
   }

package/lib/commands/verify-trust-command-action.js

@@ -6,8 +6,8 @@
 
 'use strict';
 
-const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { runVerifyTrustForExternalSystem } = require('./verify-trust-external');
 const { normalizeTestTrustCliOptions } = require('./test-trust-cli-options');
 const { displayVerifyTrustTTY } = require('../lifecycle/report-display');
@@ -30,6 +30,8 @@ async function runVerifyTrustCommandAction(appName, options, cmd) {
     timeout: opts.timeout
   });
 
+  const exitCode = exitCodeFromVerdict(result.verdict);
+
   if (opts.json) {
     const envelope = buildJsonEnvelope(
       {
@@ -44,12 +46,11 @@ async function runVerifyTrustCommandAction(appName, options, cmd) {
       },
       opts.details || opts.verbose
     );
-    logger.log(JSON.stringify(envelope, null, 2));
-  } else {
-    displayVerifyTrustTTY(result.systemKey, result, { details: opts.verbose || opts.details });
+    await writeJsonEnvelopeAndExit(envelope, exitCode);
+    return;
   }
 
-  const exitCode = exitCodeFromVerdict(result.verdict);
+  displayVerifyTrustTTY(result.systemKey, result, { details: opts.verbose || opts.details });
   if (exitCode !== 0) {
     process.exit(exitCode);
   }

package/lib/datasource/capability/relate-operations.js

@@ -78,23 +78,41 @@ function _buildRelationMetadataSchema({ relationName, targetDoc, resolvedTargetF
   return out;
 }
 
+function relationNameFromCarrier(fields) {
+  const raw = String((Array.isArray(fields) && fields[0]) || '').trim();
+  if (!raw) {
+    return '';
+  }
+  if (/^[a-z][a-zA-Z0-9]*$/.test(raw)) {
+    return raw;
+  }
+  const camel = raw.replace(/[-_]([a-zA-Z0-9])/g, (_, ch) => String(ch).toUpperCase());
+  return /^[a-z][a-zA-Z0-9]*$/.test(camel) ? camel : '';
+}
+
 /**
  * FK `name` must match schema: ^[a-z][a-zA-Z0-9]*$
+ * Defaults to the published carrier (fields[0]) when --relation-name is omitted.
  *
  * @param {string} raw
+ * @param {string[]} [fields]
  * @returns {string}
  */
-function normalizeRelationName(raw) {
+function normalizeRelationName(raw, fields) {
   const s = String(raw || '').trim();
-  if (!s) {
-    throw new Error('--relation-name is required');
+  if (s) {
+    if (!/^[a-z][a-zA-Z0-9]*$/.test(s)) {
+      throw new Error(
+        `--relation-name "${s}" must match ^[a-z][a-zA-Z0-9]*$ (camelCase)`
+      );
+    }
+    return s;
   }
-  if (!/^[a-z][a-zA-Z0-9]*$/.test(s)) {
-    throw new Error(
-      `--relation-name "${s}" must match ^[a-z][a-zA-Z0-9]*$ (camelCase)`
-    );
+  const fromField = relationNameFromCarrier(fields);
+  if (fromField) {
+    return fromField;
   }
-  return s;
+  throw new Error('--relation-name is required when --field is not a camelCase carrier');
 }
 
 /**
@@ -287,9 +305,9 @@ function buildForeignKeyRow(name, fields, targetDatasource, targetFields, option
  * }}
  */
 function applyCapabilityRelate(doc, opts) {
-  const name = normalizeRelationName(opts.relationName);
-  const targetDatasource = normalizeTargetDatasource(opts.targetDatasource);
   const { fields, targetFields } = parseRelateFields(opts);
+  const name = normalizeRelationName(opts.relationName, fields);
+  const targetDatasource = normalizeTargetDatasource(opts.targetDatasource);
 
   const d = deepClone(doc);
   if (!Array.isArray(d.foreignKeys)) {

package/lib/datasource/capability/run-capability-relate.js

@@ -25,13 +25,18 @@ function loadTargetDocLocal(targetDatasourceKey) {
   return localTarget.ok ? readJsonFile(localTarget.path) : null;
 }
 
-async function maybeFetchRemoteTargetConfig({ systemKeyForAuth, targetDatasourceKey }) {
+async function maybeFetchRemoteTargetConfig({
+  systemKeyForAuth,
+  targetSystemKey,
+  targetDatasourceKey
+}) {
   const remoteFetchMeta = { attempted: false, ok: false, notAuthenticated: false };
-  if (!systemKeyForAuth) {
+  const authKey = String(targetSystemKey || systemKeyForAuth || '').trim();
+  if (!authKey) {
     return { remoteTargetConfig: null, remoteFetchMeta };
   }
   remoteFetchMeta.attempted = true;
-  const remote = await tryFetchDatasourceConfig(systemKeyForAuth, targetDatasourceKey, { silent: true });
+  const remote = await tryFetchDatasourceConfig(authKey, targetDatasourceKey, { silent: true });
   if (remote.ok) {
     return {
       remoteTargetConfig: remote.datasourceConfig,
@@ -105,6 +110,38 @@ function applyRelateAndValidateSchema(parsed, opts, semanticWarnings, remoteVali
   return { result, validation };
 }
 
+function persistOrDryRunRelate({
+  opts,
+  resolvedPath,
+  result,
+  validation,
+  semantic,
+  remoteFetchMeta
+}) {
+  if (opts.dryRun) {
+    return buildRelateResultEnvelope({
+      dryRun: true,
+      resolvedPath,
+      result,
+      backupPath: null,
+      validation,
+      semanticWarnings: semantic.warnings,
+      remoteValidation: remoteFetchMeta
+    });
+  }
+  const backupPath = writeBackup(resolvedPath, Boolean(opts.noBackup));
+  atomicWriteJson(resolvedPath, result.doc);
+  return buildRelateResultEnvelope({
+    dryRun: false,
+    resolvedPath,
+    result,
+    backupPath,
+    validation,
+    semanticWarnings: semantic.warnings,
+    remoteValidation: remoteFetchMeta
+  });
+}
+
 /**
  * @typedef {object} RunCapabilityRelateOpts
  * @property {string} fileOrKey
@@ -137,8 +174,10 @@ async function runCapabilityRelate(opts) {
 
   const targetDocLocal = loadTargetDocLocal(opts.targetDatasource);
   const systemKeyForAuth = resolveSystemKeyForAuth(parsed);
+  const targetSystemKey = resolveSystemKeyForAuth(targetDocLocal) || systemKeyForAuth;
   const { remoteTargetConfig, remoteFetchMeta } = await maybeFetchRemoteTargetConfig({
     systemKeyForAuth,
+    targetSystemKey,
     targetDatasourceKey: opts.targetDatasource
   });
   const semantic = runSemanticValidation({
@@ -159,33 +198,17 @@ async function runCapabilityRelate(opts) {
     semantic.warnings,
     remoteFetchMeta
   );
-
-  if (opts.dryRun) {
-    return buildRelateResultEnvelope({
-      dryRun: true,
-      resolvedPath,
-      result,
-      backupPath: null,
-      validation,
-      semanticWarnings: semantic.warnings,
-      remoteValidation: remoteFetchMeta
-    });
-  }
-
-  const backupPath = writeBackup(resolvedPath, Boolean(opts.noBackup));
-  atomicWriteJson(resolvedPath, result.doc);
-
-  return buildRelateResultEnvelope({
-    dryRun: false,
+  return persistOrDryRunRelate({
+    opts,
     resolvedPath,
     result,
-    backupPath,
     validation,
-    semanticWarnings: semantic.warnings,
-    remoteValidation: remoteFetchMeta
+    semantic,
+    remoteFetchMeta
   });
 }
 
 module.exports = {
-  runCapabilityRelate
+  runCapabilityRelate,
+  resolveSystemKeyForAuth
 };

package/lib/datasource/datasource-identifier.js

@@ -56,12 +56,20 @@ function pickIntegrationAppForDatasourceIdentifier(identifier, appNames) {
   if (!id) {
     return null;
   }
-  const matches = appNames.filter(app => id === app || id.startsWith(`${app}-`));
-  if (matches.length === 0) {
-    return null;
+  const prefixMatches = (appNames || []).filter((app) => id === app || id.startsWith(`${app}-`));
+  if (prefixMatches.length > 0) {
+    prefixMatches.sort((a, b) => b.length - a.length);
+    return prefixMatches[0];
+  }
+  const keyMatches = (appNames || []).filter((app) => appHasDatasourceIdentifier(app, id));
+  if (keyMatches.length === 1) {
+    return keyMatches[0];
+  }
+  if (keyMatches.length > 1) {
+    keyMatches.sort((a, b) => b.length - a.length);
+    return keyMatches[0];
   }
-  matches.sort((a, b) => b.length - a.length);
-  return matches[0];
+  return null;
 }
 
 /**