@aifabrix/builder 2.54.1 → 2.55.0

package/lib/external-system/deploy.js

@@ -31,6 +31,7 @@ const { syncDeployJsonFromSources } = require('./sync-deploy-manifest');
 const { runDeployGateOrchestrator } = require('../commands/deploy-gate-orchestrator');
 const { runPostPublishDataSync } = require('../commands/run-post-publish-data-sync');
 const { uploadDigitalWorkerIfNeeded, deployRoleAssistantShellIfNeeded } = require('./deploy-helpers');
+const { createDataplanePublishedCheck } = require('./deploy-dataplane-published');
 
 /**
  * Validates manifest on dataplane (dry-run) before controller deploy.
@@ -194,9 +195,10 @@ const EXTERNAL_DEPLOY_POLL_INTERVAL_MS = 2000;
 /** 300 × 2s ≈ 10 minutes — must cover controller publish-job max wait with gates. */
 const EXTERNAL_DEPLOY_POLL_MAX_ATTEMPTS = 300;
 
-function buildExternalDeployPollOpts(options) {
+function buildExternalDeployPollOpts(options, extra = {}) {
   return {
     ...options,
+    ...extra,
     poll: true,
     pollInterval:
       options.pollInterval !== undefined ? options.pollInterval : EXTERNAL_DEPLOY_POLL_INTERVAL_MS,
@@ -300,7 +302,15 @@ async function executeDeployAndDisplay(manifest, controllerUrl, environment, aut
     controllerUrl,
     environment,
     authConfig,
-    buildExternalDeployPollOpts(options)
+    buildExternalDeployPollOpts(options, {
+      isDataplanePublished: createDataplanePublishedCheck({
+        controllerUrl,
+        environment,
+        authConfig,
+        systemKey: manifest.key,
+        dataplaneUrl: options.knownDataplaneUrl
+      })
+    })
   );
 
   const deploymentOutcome = parseControllerDeploymentOutcome(result);

package/lib/external-system/download-role-assistant.js

@@ -24,13 +24,23 @@ const {
   isPlatformShellKind
 } = require('../utils/platform-shell-package');
 
-const CONNECTED_SYSTEM_DRY_RUN_FILES = [
-  'deploy.json',
-  'application.yaml',
-  'system.yaml',
-  'env.template',
-  'README.md'
-];
+function connectedSystemDryRunFileNames(systemKey, dataSources, format) {
+  const { getExternalDatasourceFileName } = require('../generator/split-variables');
+  const ext = format === 'json' ? 'json' : 'yaml';
+  const names = [
+    `${systemKey}-deploy.json`,
+    `application.${ext}`,
+    `${systemKey}-system.${ext}`,
+    'env.template',
+    'README.md'
+  ];
+  const list = Array.isArray(dataSources) ? dataSources : [];
+  for (let i = 0; i < list.length; i += 1) {
+    const yamlName = getExternalDatasourceFileName(systemKey, list[i], i);
+    names.push(ext === 'json' ? yamlName.replace(/\.yaml$/i, '.json') : yamlName);
+  }
+  return names;
+}
 
 async function maybeExportRoleAssistantEvidenceArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options) {
   try {
@@ -47,6 +57,23 @@ async function maybeExportRoleAssistantEvidenceArtifacts(systemKey, manifest, da
   }
 }
 
+async function maybeExportRoleAssistantTestsArtifacts(systemKey, dataplaneUrl, authConfig, options) {
+  try {
+    const { exportRoleAssistantTests } = require('../role-assistant/test-pack-sync');
+    const testsResult = await exportRoleAssistantTests({
+      systemKey,
+      dataplaneUrl,
+      authConfig,
+      options
+    });
+    if (testsResult && testsResult.skipped) {
+      logger.log(formatWarningLine(`Role assistant tests export skipped: ${testsResult.reason}`));
+    }
+  } catch (testsErr) {
+    logger.log(formatWarningLine(`Role assistant tests export skipped: ${testsErr.message}`));
+  }
+}
+
 async function maybeExportRoleAssistantKnowledgeArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options) {
   try {
     const knowledgeResult = await exportRoleAssistantKnowledge({
@@ -67,19 +94,17 @@ async function runRoleAssistantDownloadSidecars(params) {
   const { systemKey, manifest, dataplaneUrl, authConfig, options = {} } = params;
   await maybeExportRoleAssistantEvidenceArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options);
   await maybeExportRoleAssistantKnowledgeArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options);
+  await maybeExportRoleAssistantTestsArtifacts(systemKey, dataplaneUrl, authConfig, options);
 }
 
-function logConnectedSystemDryRunFiles(systemKey) {
+function logConnectedSystemDryRunFiles(systemKey, dataSources, format) {
   logger.log(metadata('Would create:'));
-  CONNECTED_SYSTEM_DRY_RUN_FILES.forEach((name) => {
-    const fileName = name === 'deploy.json' || name === 'system.yaml'
-      ? `${systemKey}-${name}`
-      : name;
+  connectedSystemDryRunFileNames(systemKey, dataSources, format).forEach((fileName) => {
     logger.log(metadata(`  - integration/${systemKey}/${fileName}`));
   });
 }
 
-function handleDownloadDryRun(systemKey, dataplaneUrl, application) {
+function handleDownloadDryRun(systemKey, dataplaneUrl, application, dataSources, format) {
   logger.log(formatWarningLine('Dry run mode: no files written.'));
   logger.log(metadata(`Would fetch: ${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`));
   if (isEnterpriseKnowledgeKind(application)) {
@@ -91,7 +116,7 @@ function handleDownloadDryRun(systemKey, dataplaneUrl, application) {
     logger.log(metadata(`  - role-assistant/${systemKey}/role-assistant.yaml`));
     return;
   }
-  logConnectedSystemDryRunFiles(systemKey);
+  logConnectedSystemDryRunFiles(systemKey, dataSources, format);
 }
 
 async function downloadDigitalWorkerPackage(params) {
@@ -130,5 +155,6 @@ async function downloadPlatformShellIfNeeded(params) {
 module.exports = {
   runRoleAssistantDownloadSidecars,
   downloadPlatformShellIfNeeded,
-  handleDownloadDryRun
+  handleDownloadDryRun,
+  connectedSystemDryRunFileNames
 };

package/lib/external-system/download.js

@@ -421,7 +421,13 @@ async function downloadExternalSystem(systemKey, options = {}) {
     );
     const manifest = await downloadFullManifest(dataplaneUrl, systemKey, authConfig, options);
     if (options.dryRun) {
-      handleDownloadDryRun(systemKey, dataplaneUrl, manifest.application);
+      handleDownloadDryRun(
+        systemKey,
+        dataplaneUrl,
+        manifest.application,
+        manifest.dataSources,
+        format
+      );
       return;
     }
     const platformHandled = await downloadPlatformShellIfNeeded({

package/lib/generator/wizard-datasource-key.js

@@ -0,0 +1,54 @@
+/**
+ * Canonical kebab datasource keys for wizard generate-config.
+ *
+ * @fileoverview Wizard datasource key segments
+ */
+
+'use strict';
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+function toKeySegment(str) {
+  if (!str || typeof str !== 'string') {
+    return 'default';
+  }
+  const withHyphens = str.replace(/([A-Z])/g, '-$1').toLowerCase();
+  const sanitized = withHyphens.replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  return sanitized || 'default';
+}
+
+/**
+ * @param {string} finalSystemKey
+ * @param {{ key?: string, entityName?: string, entityType?: string, entityKey?: string }} ds
+ * @param {string} originalPrefix
+ * @param {Set<string>} [usedKeys]
+ * @returns {string}
+ */
+function wizardCanonicalDatasourceKey(finalSystemKey, ds, originalPrefix, usedKeys) {
+  const dsKey = String(ds.key || '').trim();
+  let segment;
+  if (dsKey && originalPrefix && dsKey.startsWith(originalPrefix)) {
+    segment = toKeySegment(dsKey.substring(originalPrefix.length));
+  } else {
+    const raw = ds.entityName || dsKey || ds.entityType || ds.entityKey || 'default';
+    segment = toKeySegment(raw);
+  }
+  let candidate = segment.includes('-') && !segment.startsWith(`${finalSystemKey}-`)
+    ? segment
+    : `${finalSystemKey}-${segment}`;
+  if (usedKeys && usedKeys.has(candidate)) {
+    let suffix = 2;
+    while (usedKeys.has(`${candidate}-${suffix}`)) {
+      suffix += 1;
+    }
+    candidate = `${candidate}-${suffix}`;
+  }
+  return candidate;
+}
+
+module.exports = {
+  toKeySegment,
+  wizardCanonicalDatasourceKey
+};

package/lib/generator/wizard.js

@@ -17,19 +17,7 @@ const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { systemKeyToKvPrefix, securityKeyToVar, isValidKvPath } = require('../utils/credential-secrets-env');
 const { generateExternalEnvTemplateContent } = require('../utils/external-env-template');
 const { generateReadme } = require('./wizard-readme');
-
-/**
- * Converts a string to a schema-valid key segment (lowercase letters, numbers, hyphens only).
- * e.g. "recordStorage" -> "record-storage", "documentStorage" -> "document-storage"
- * @param {string} str - Raw entity type or key segment (may be camelCase)
- * @returns {string} Segment matching ^[a-z0-9-]+$
- */
-function toKeySegment(str) {
-  if (!str || typeof str !== 'string') return 'default';
-  const withHyphens = str.replace(/([A-Z])/g, '-$1').toLowerCase();
-  const sanitized = withHyphens.replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-  return sanitized || 'default';
-}
+const { toKeySegment, wizardCanonicalDatasourceKey } = require('./wizard-datasource-key');
 
 const { normalizeAuthenticationToSystemKey } = require('../utils/authentication-shape');
 
@@ -118,10 +106,46 @@ async function writeDatasourceYamlFiles(appPath, finalSystemKey, datasourceConfi
  * @param {string} [params.aiGeneratedReadme] - Optional AI-generated README content
  * @returns {Promise<Object>} Object with file paths
  */
-async function generateConfigFilesForWizard(params) {
-  const { appPath, appName, finalSystemKey, systemFileName, datasourceFileNames, systemConfig, datasourceConfigs, aiGeneratedReadme, format } = params;
+async function writeWizardEnvTemplate(appPath, systemConfig) {
+  const envTemplatePath = path.join(appPath, 'env.template');
+  const envTemplateContent = generateExternalEnvTemplateContent(systemConfig);
+  await fs.writeFile(envTemplatePath, envTemplateContent, 'utf8');
+  logger.log(formatSuccessLine('Generated env.template'));
+  try {
+    const secretsEnsure = require('../core/secrets-ensure');
+    await secretsEnsure.ensureSecretsFromEnvTemplate(envTemplatePath, {
+      emptyValuesForCredentials: true
+    });
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      logger.warn(`Could not ensure integration placeholder secrets: ${err.message}`);
+    }
+  }
+  return envTemplatePath;
+}
 
-  // Generate or update application config with externalIntegration block
+async function writeWizardDeployManifest(appPath, appName, finalSystemKey) {
+  const { generateControllerManifest, toDeployJsonShape } = require('./external-controller-manifest');
+  const manifest = await generateControllerManifest(appName, { appPath });
+  const deployJson = toDeployJsonShape(manifest);
+  const deployManifestPath = path.join(appPath, `${finalSystemKey}-deploy.json`);
+  await fs.writeFile(deployManifestPath, JSON.stringify(deployJson, null, 2), 'utf8');
+  logger.log(formatSuccessLine(`Generated deployment manifest: ${finalSystemKey}-deploy.json`));
+  return deployManifestPath;
+}
+
+async function generateConfigFilesForWizard(params) {
+  const {
+    appPath,
+    appName,
+    finalSystemKey,
+    systemFileName,
+    datasourceFileNames,
+    systemConfig,
+    datasourceConfigs,
+    aiGeneratedReadme,
+    format
+  } = params;
   const configPath = await generateOrUpdateVariablesYaml({
     appPath,
     appName,
@@ -131,21 +155,7 @@ async function generateConfigFilesForWizard(params) {
     systemConfig,
     format: format || 'yaml'
   });
-
-  // Generate env.template with Authentication and Configuration sections (Handlebars)
-  const envTemplatePath = path.join(appPath, 'env.template');
-  const envTemplateContent = generateExternalEnvTemplateContent(systemConfig);
-  await fs.writeFile(envTemplatePath, envTemplateContent, 'utf8');
-  logger.log(formatSuccessLine('Generated env.template'));
-
-  try {
-    const secretsEnsure = require('../core/secrets-ensure');
-    await secretsEnsure.ensureSecretsFromEnvTemplate(envTemplatePath, { emptyValuesForCredentials: true });
-  } catch (err) {
-    if (err.code !== 'ENOENT') logger.warn(`Could not ensure integration placeholder secrets: ${err.message}`);
-  }
-
-  // Generate README.md (use AI-generated content if available)
+  const envTemplatePath = await writeWizardEnvTemplate(appPath, systemConfig);
   await generateReadme({
     appPath,
     appName,
@@ -155,21 +165,16 @@ async function generateConfigFilesForWizard(params) {
     aiGeneratedContent: aiGeneratedReadme,
     format
   });
-
-  // Generate deployment scripts
-  const deployScripts = await generateDeployScripts(appPath, finalSystemKey, systemFileName, datasourceFileNames);
-
-  // Generate deployment manifest (<systemKey>-deploy.json) using controller format
-  const { generateControllerManifest, toDeployJsonShape } = require('./external-controller-manifest');
-  const manifest = await generateControllerManifest(appName, { appPath });
-  const deployJson = toDeployJsonShape(manifest);
-  const deployManifestPath = path.join(appPath, `${finalSystemKey}-deploy.json`);
-  await fs.writeFile(deployManifestPath, JSON.stringify(deployJson, null, 2), 'utf8');
-  logger.log(formatSuccessLine(`Generated deployment manifest: ${finalSystemKey}-deploy.json`));
-
+  const deployScripts = await generateDeployScripts(
+    appPath,
+    finalSystemKey,
+    systemFileName,
+    datasourceFileNames
+  );
+  const deployManifestPath = await writeWizardDeployManifest(appPath, appName, finalSystemKey);
   return {
     variablesPath: configPath,
-    envTemplatePath: path.join(appPath, 'env.template'),
+    envTemplatePath,
     readmePath: path.join(appPath, 'README.md'),
     applicationSchemaPath: deployManifestPath,
     ...deployScripts
@@ -190,16 +195,10 @@ async function prepareWizardContext(appName, systemConfig, datasourceConfigs) {
     appDisplayName
   );
   const originalPrefix = `${originalSystemKey}-`;
+  const usedKeys = new Set();
   const updatedDatasourceConfigs = datasourceConfigs.map(ds => {
-    let newKey;
-    const dsKey = ds.key || '';
-    if (dsKey && dsKey.startsWith(originalPrefix)) {
-      newKey = `${finalSystemKey}-${dsKey.substring(originalPrefix.length)}`;
-    } else {
-      const entityType = ds.entityType || ds.entityKey || dsKey.split('-').pop() || 'default';
-      const keySegment = toKeySegment(entityType);
-      newKey = `${finalSystemKey}-${keySegment}`;
-    }
+    const newKey = wizardCanonicalDatasourceKey(finalSystemKey, ds, originalPrefix, usedKeys);
+    usedKeys.add(newKey);
     const entityType = ds.entityType || ds.entityKey || newKey.split('-').pop() || 'default';
     const entityDisplayName = String(entityType).charAt(0).toUpperCase() + String(entityType).slice(1).replace(/-/g, ' ');
     return { ...ds, key: newKey, systemKey: finalSystemKey, displayName: ds.displayName || `${appDisplayName} ${entityDisplayName}` };
@@ -481,6 +480,8 @@ const { generateDeployScripts } = require('./deploy-script');
 
 module.exports = {
   generateWizardFiles,
-  generateDeployScripts
+  generateDeployScripts,
+  wizardCanonicalDatasourceKey,
+  toKeySegment
 };
 

package/lib/integration-definition/apply-datasource-keys.js

@@ -0,0 +1,75 @@
+/**
+ * Canonical tenant-global datasource keys for BID apply.
+ *
+ * @fileoverview Prefix single-token keys; keep unique kebab keys
+ */
+
+'use strict';
+
+const { isScopedKebabKey } = require('../commands/repair-datasource-key-skip');
+
+/**
+ * @param {string} dsKey
+ * @param {string} systemKey
+ * @returns {string}
+ */
+function canonicalDatasourceKey(dsKey, systemKey) {
+  const key = String(dsKey || '').trim();
+  const sys = String(systemKey || '').trim();
+  if (!key) {
+    return key;
+  }
+  if (sys && key.startsWith(`${sys}-`)) {
+    return key;
+  }
+  if (isScopedKebabKey(key)) {
+    return key;
+  }
+  return sys ? `${sys}-${key}` : key;
+}
+
+/**
+ * @param {Array<{ key?: string }>} datasources
+ * @param {string} systemKey
+ * @returns {Map<string, string>}
+ */
+function canonicalDatasourceKeyMap(datasources, systemKey) {
+  const map = new Map();
+  for (const ds of datasources || []) {
+    const from = String(ds.key || '').trim();
+    if (!from) {
+      continue;
+    }
+    map.set(from, canonicalDatasourceKey(from, systemKey));
+  }
+  return map;
+}
+
+/**
+ * @param {string} systemKey
+ * @param {string} canonicalKey
+ * @returns {string}
+ */
+function datasourceFileName(systemKey, canonicalKey) {
+  const sys = String(systemKey || '');
+  const key = String(canonicalKey || '');
+  const suffix = sys && key.startsWith(`${sys}-`) ? key.slice(sys.length + 1) : key;
+  return `${sys}-datasource-${suffix}.json`;
+}
+
+/**
+ * @param {string} key
+ * @param {Map<string, string>} keyMap
+ * @returns {string}
+ */
+function remapKey(key, keyMap) {
+  const raw = String(key || '').trim();
+  return (keyMap && keyMap.get(raw)) || raw;
+}
+
+module.exports = {
+  canonicalDatasourceKey,
+  canonicalDatasourceKeyMap,
+  datasourceFileName,
+  remapKey
+};

package/lib/integration-definition/apply-relationships.js

@@ -0,0 +1,195 @@
+/**
+ * Compile BID relationships[] into EDS foreignKeys and child type:fk dimensions.
+ *
+ * @fileoverview BID relationship compile for apply
+ */
+
+'use strict';
+
+const { remapKey } = require('./apply-datasource-keys');
+
+/**
+ * @param {Record<string, unknown>} rel
+ * @returns {string[]}
+ */
+function carrierFieldsFromRelationship(rel) {
+  if (Array.isArray(rel.fields) && rel.fields.length > 0) {
+    return rel.fields.map((row) => String(row || '').trim()).filter(Boolean);
+  }
+  if (typeof rel.field === 'string' && rel.field.trim()) {
+    return [rel.field.trim()];
+  }
+  if (typeof rel.carrier === 'string' && rel.carrier.trim()) {
+    return [rel.carrier.trim()];
+  }
+  return [];
+}
+
+/**
+ * @param {string[]} fields
+ * @returns {string}
+ */
+function fkNameFromCarrier(fields) {
+  const raw = String((fields && fields[0]) || '').trim();
+  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 : '';
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @param {string} carrier
+ * @returns {void}
+ */
+function carrierPropertyNode(props, carrier) {
+  const existing = props[carrier] && typeof props[carrier] === 'object'
+    ? /** @type {Record<string, unknown>} */ (props[carrier])
+    : { type: 'string' };
+  return { ...existing, type: existing.type || 'string', index: true, filter: true };
+}
+
+function ensureCarrierMappings(body, carrier) {
+  if (!body.fieldMappings || typeof body.fieldMappings !== 'object') {
+    body.fieldMappings = { attributes: {} };
+  }
+  const mappings = /** @type {Record<string, unknown>} */ (body.fieldMappings);
+  if (!mappings.attributes || typeof mappings.attributes !== 'object') {
+    mappings.attributes = {};
+  }
+  const attrs = /** @type {Record<string, unknown>} */ (mappings.attributes);
+  if (!attrs[carrier]) {
+    attrs[carrier] = { expression: `{{raw.${carrier}}}`, description: 'Join carrier' };
+  }
+}
+
+function ensureCarrierExposed(body, carrier) {
+  if (!body.exposed || typeof body.exposed !== 'object') {
+    body.exposed = {};
+  }
+  const exposed = /** @type {Record<string, unknown>} */ (body.exposed);
+  const filterable = Array.isArray(exposed.filterable) ? [...exposed.filterable] : [];
+  if (!filterable.includes(carrier)) {
+    filterable.push(carrier);
+  }
+  exposed.filterable = filterable;
+}
+
+function ensureCarrierOnChild(body, carrier) {
+  if (!body.metadataSchema || typeof body.metadataSchema !== 'object') {
+    body.metadataSchema = { type: 'object', properties: {} };
+  }
+  const schema = /** @type {Record<string, unknown>} */ (body.metadataSchema);
+  if (!schema.properties || typeof schema.properties !== 'object') {
+    schema.properties = {};
+  }
+  const props = /** @type {Record<string, unknown>} */ (schema.properties);
+  props[carrier] = carrierPropertyNode(props, carrier);
+  ensureCarrierMappings(body, carrier);
+  ensureCarrierExposed(body, carrier);
+}
+
+/**
+ * @param {Record<string, unknown>} childBody
+ * @param {Record<string, unknown>} parentBody
+ * @param {string} fkName
+ * @returns {void}
+ */
+function copyParentCatalogDimsAsFk(childBody, parentBody, fkName) {
+  const parentDims = parentBody.dimensions;
+  if (!parentDims || typeof parentDims !== 'object' || Array.isArray(parentDims)) {
+    return;
+  }
+  if (!childBody.dimensions || typeof childBody.dimensions !== 'object') {
+    childBody.dimensions = {};
+  }
+  const childDims = /** @type {Record<string, unknown>} */ (childBody.dimensions);
+  for (const [dimKey, binding] of Object.entries(parentDims)) {
+    if (!binding || typeof binding !== 'object' || childDims[dimKey]) {
+      continue;
+    }
+    childDims[dimKey] = { type: 'fk', via: [{ fk: fkName, dimension: dimKey }] };
+  }
+}
+
+/**
+ * @param {Array<{ name: string, body: Record<string, unknown> }>} dsFiles
+ * @returns {Map<string, Record<string, unknown>>}
+ */
+function bodiesByKey(dsFiles) {
+  const map = new Map();
+  for (const file of dsFiles || []) {
+    const key = String(file.body && file.body.key ? file.body.key : '').trim();
+    if (key) {
+      map.set(key, file.body);
+    }
+  }
+  return map;
+}
+
+/**
+ * @param {Record<string, unknown>} childBody
+ * @param {string} name
+ * @param {string[]} fields
+ * @param {string} targetKey
+ * @returns {void}
+ */
+function upsertForeignKey(childBody, name, fields, targetKey) {
+  if (!Array.isArray(childBody.foreignKeys)) {
+    childBody.foreignKeys = [];
+  }
+  const rows = /** @type {Array<Record<string, unknown>>} */ (childBody.foreignKeys);
+  const next = {
+    name,
+    fields,
+    targetDatasource: targetKey,
+    targetFields: ['externalId']
+  };
+  const idx = rows.findIndex((row) => row && row.name === name);
+  if (idx >= 0) {
+    rows[idx] = { ...rows[idx], ...next };
+    return;
+  }
+  rows.push(next);
+}
+
+/**
+ * @param {Array<{ name: string, body: Record<string, unknown> }>} dsFiles
+ * @param {unknown[]} relationships
+ * @param {Map<string, string>} keyMap
+ * @returns {void}
+ */
+function applyBidRelationships(dsFiles, relationships, keyMap) {
+  if (!Array.isArray(relationships) || relationships.length === 0) {
+    return;
+  }
+  const bodies = bodiesByKey(dsFiles);
+  for (const rel of relationships) {
+    if (!rel || typeof rel !== 'object') {
+      continue;
+    }
+    const row = /** @type {Record<string, unknown>} */ (rel);
+    const fields = carrierFieldsFromRelationship(row);
+    const fkName = fkNameFromCarrier(fields);
+    if (!fkName) {
+      continue;
+    }
+    const fromKey = remapKey(String(row.from || ''), keyMap);
+    const toKey = remapKey(String(row.to || ''), keyMap);
+    const childBody = bodies.get(fromKey);
+    const parentBody = bodies.get(toKey);
+    if (!childBody || !parentBody) {
+      continue;
+    }
+    ensureCarrierOnChild(childBody, fkName);
+    upsertForeignKey(childBody, fkName, [fkName], toKey);
+    copyParentCatalogDimsAsFk(childBody, parentBody, fkName);
+  }
+}
+
+module.exports = {
+  applyBidRelationships,
+  carrierFieldsFromRelationship,
+  fkNameFromCarrier
+};