@aifabrix/builder 2.45.5 → 2.46.0

package/lib/commands/login.js

@@ -85,7 +85,7 @@ async function normalizeControllerUrl(options) {
   if (!controllerUrl) {
     controllerUrl = await resolveControllerUrl();
   }
-  controllerUrl = String(controllerUrl).replace(/\/+$/, '');
+  controllerUrl = String(controllerUrl).trim().replace(/\/+$/, '');
   // Save controller URL to config
   await setControllerUrl(controllerUrl);
   if (!options.compact) {
@@ -170,6 +170,14 @@ async function handleDeviceCodeLoginFlow(controllerUrl, environment, options) {
  */
 async function refreshDataplaneVersionIfNeeded(controllerUrl, options, skipRefresh) {
   if (skipRefresh) return;
+  if (!options.compact) {
+    const { LOGIN_POST_REFRESH_BUDGET_MS } = require('./auth-status-dataplane-version');
+    logger.log(
+      chalk.gray(
+        `Syncing dataplane version cache (optional, up to ${Math.round(LOGIN_POST_REFRESH_BUDGET_MS / 1000)}s)...`
+      )
+    );
+  }
   await tryRefreshDataplaneVersionAfterLogin(controllerUrl, options);
 }
 
@@ -213,7 +221,8 @@ async function handleLogin(options) {
   const method = await determineAuthMethod(options.method);
   validateScopeOptions(method, options);
 
-  const skipRefresh = options.skipDataplaneVersionRefresh === true;
+  const skipRefresh =
+    options.skipDataplaneVersionRefresh === true || options.skipVersionCache === true;
   const flow = await executeLoginMethod(method, controllerUrl, environment, options, skipRefresh);
   if (flow === 'device') return;
 

package/lib/commands/repair-auth-apply.js

@@ -0,0 +1,127 @@
+/**
+ * Repair --auth: canonical authentication blocks and bearerToken preset.
+ *
+ * Applies canonical authentication blocks for repair --auth.
+ *
+ * @fileoverview Repair authentication method application
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { buildAuthenticationFromMethod } = require('../external-system/generator');
+
+/** Repair CLI --auth values (normalized lowercase). */
+const ALLOWED_REPAIR_AUTH = [
+  'oauth2',
+  'aad',
+  'apikey',
+  'bearertoken',
+  'bearerkey',
+  'basic',
+  'queryparam',
+  'oidc',
+  'hmac',
+  'none'
+];
+
+const PRESERVED_VARIABLE_KEYS = ['baseUrl', 'testEndpoint'];
+
+/**
+ * @param {string} authOption - Raw --auth value
+ * @returns {string} Normalized lowercase auth option
+ */
+function normalizeRepairAuthOption(authOption) {
+  return String(authOption || '').trim().toLowerCase();
+}
+
+/**
+ * @param {string} authOption - Normalized --auth value
+ * @returns {boolean}
+ */
+function isAllowedRepairAuth(authOption) {
+  return ALLOWED_REPAIR_AUTH.includes(normalizeRepairAuthOption(authOption));
+}
+
+/**
+ * Builds authentication block for repair --auth.
+ * @param {string} systemKey - System key
+ * @param {string} authOption - Normalized repair auth (e.g. bearertoken, apikey)
+ * @returns {{ method: string, variables: Object, security: Object }}
+ */
+function buildAuthenticationForRepair(systemKey, authOption) {
+  const normalized = normalizeRepairAuthOption(authOption);
+  const schemaMethod =
+    normalized === 'queryparam'
+      ? 'queryParam'
+      : normalized === 'bearertoken' || normalized === 'bearerkey'
+        ? 'bearerToken'
+        : normalized;
+  return buildAuthenticationFromMethod(systemKey, schemaMethod);
+}
+
+/**
+ * Merges preserved connectivity fields from existing auth into template variables.
+ * @param {Object} mergedVariables - Target variables object (mutated)
+ * @param {Object} existingVars - Prior authentication.variables
+ */
+function mergePreservedAuthVariables(mergedVariables, existingVars) {
+  if (!existingVars || typeof existingVars !== 'object') return;
+  for (const key of PRESERVED_VARIABLE_KEYS) {
+    if (existingVars[key] !== undefined && existingVars[key] !== null) {
+      mergedVariables[key] = existingVars[key];
+    }
+  }
+}
+
+/**
+ * Human-readable label for repair change log.
+ * @param {string} authOption - Normalized repair auth
+ * @returns {string}
+ */
+function repairAuthChangeLabel(authOption) {
+  const normalized = normalizeRepairAuthOption(authOption);
+  if (normalized === 'bearertoken' || normalized === 'bearerkey') return 'bearerToken';
+  return normalized;
+}
+
+const MISSING_TEST_ENDPOINT_WARNING =
+  'authentication.variables.testEndpoint is missing for apikey/bearerToken auth — add a GET URL for credential/E2E tests (e.g. /crm/v3/objects/contacts?limit=1, or a path resolved against baseUrl).';
+
+/**
+ * Warn when apikey auth (including bearerToken preset) has no testEndpoint.
+ * @param {Object} authentication - authentication block on system file
+ * @param {string[]} warnings - Mutable warnings list
+ */
+function appendTestEndpointWarningIfMissing(authentication, warnings) {
+  const method = String(authentication?.method || '').toLowerCase();
+  if (method !== 'apikey' && method !== 'bearertoken') return;
+  const testEndpoint = String(authentication?.variables?.testEndpoint || '').trim();
+  if (testEndpoint) return;
+  if (warnings.includes(MISSING_TEST_ENDPOINT_WARNING)) return;
+  warnings.push(MISSING_TEST_ENDPOINT_WARNING);
+}
+
+/**
+ * Audit system authentication after repair (with or without --auth).
+ * @param {Object} systemParsed - Parsed system config
+ * @param {string[]} warnings - Mutable warnings list
+ */
+function auditRepairAuthenticationWarnings(systemParsed, warnings) {
+  const authentication = systemParsed?.authentication || systemParsed?.auth;
+  if (!authentication || typeof authentication !== 'object') return;
+  appendTestEndpointWarningIfMissing(authentication, warnings);
+}
+
+module.exports = {
+  ALLOWED_REPAIR_AUTH,
+  MISSING_TEST_ENDPOINT_WARNING,
+  normalizeRepairAuthOption,
+  isAllowedRepairAuth,
+  buildAuthenticationForRepair,
+  mergePreservedAuthVariables,
+  repairAuthChangeLabel,
+  appendTestEndpointWarningIfMissing,
+  auditRepairAuthenticationWarnings
+};

package/lib/commands/repair-changed-files.js

@@ -0,0 +1,41 @@
+/**
+ * Track integration files touched during repair for CLI summary output.
+ *
+ * @fileoverview Repair changed-file tracking
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+
+/**
+ * Ensures backup/repair context has changed-file buckets.
+ * @param {Object} ctx - Repair backup context
+ * @returns {{ changedFiles: string[], wouldChangeFiles: string[] }}
+ */
+function ensureChangedFileBuckets(ctx) {
+  if (!ctx) return { changedFiles: [], wouldChangeFiles: [] };
+  if (!Array.isArray(ctx.changedFiles)) ctx.changedFiles = [];
+  if (!Array.isArray(ctx.wouldChangeFiles)) ctx.wouldChangeFiles = [];
+  return { changedFiles: ctx.changedFiles, wouldChangeFiles: ctx.wouldChangeFiles };
+}
+
+/**
+ * Records a file path that repair wrote or would write (dry-run).
+ * @param {string} filePath - Path to file
+ * @param {Object} ctx - Repair context with dryRun, changedFiles, wouldChangeFiles
+ */
+function trackRepairWrite(filePath, ctx) {
+  if (!filePath || !ctx) return;
+  const abs = path.resolve(filePath);
+  const { changedFiles, wouldChangeFiles } = ensureChangedFileBuckets(ctx);
+  const bucket = ctx.dryRun ? wouldChangeFiles : changedFiles;
+  if (!bucket.includes(abs)) bucket.push(abs);
+}
+
+module.exports = {
+  ensureChangedFileBuckets,
+  trackRepairWrite
+};

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

@@ -16,6 +16,7 @@ const path = require('path');
 const fs = require('fs');
 const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { backupIntegrationFile } = require('../utils/integration-file-backup');
+const { trackRepairWrite } = require('./repair-changed-files');
 
 /**
  * Returns suffix from a canonical-format filename: <systemKey>-datasource-<suffix>.<ext>.
@@ -174,8 +175,9 @@ function normalizeDatasourceKeysAndFilenames(appPath, datasourceFiles, systemKey
 
     if (parsed.key !== canonicalKey) {
       parsed.key = canonicalKey;
+      const fullPath = path.join(appPath, fileName);
+      trackRepairWrite(fullPath, backupCtx);
       if (!dryRun) {
-        const fullPath = path.join(appPath, fileName);
         backupIntegrationFile(fullPath, backupCtx);
         writeConfigFile(fullPath, parsed);
       }
@@ -185,6 +187,7 @@ function normalizeDatasourceKeysAndFilenames(appPath, datasourceFiles, systemKey
     if (fileName !== canonicalFileName) {
       const oldPath = path.join(appPath, fileName);
       const newPath = path.join(appPath, canonicalFileName);
+      trackRepairWrite(newPath, backupCtx);
       if (!dryRun && fs.existsSync(oldPath) && !fs.existsSync(newPath)) {
         backupIntegrationFile(oldPath, backupCtx);
         fs.renameSync(oldPath, newPath);

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

@@ -0,0 +1,59 @@
+/**
+ * Batch datasource file repair during external integration repair.
+ *
+ * @fileoverview Run repairDatasourceFile across integration datasource files
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
+const { backupIntegrationFile } = require('../utils/integration-file-backup');
+const { trackRepairWrite } = require('./repair-changed-files');
+const { repairDatasourceFile } = require('./repair-datasource');
+
+/**
+ * @param {string} appPath
+ * @param {string[]} datasourceFiles
+ * @param {Object} options
+ * @param {boolean} dryRun
+ * @param {string[]} changes
+ * @returns {boolean}
+ */
+function runDatasourceRepairs(appPath, datasourceFiles, options, dryRun, changes) {
+  if (!datasourceFiles || datasourceFiles.length === 0) return false;
+  let updated = false;
+  for (const fileName of datasourceFiles) {
+    const filePath = path.join(appPath, fileName);
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const parsed = loadConfigFile(filePath);
+      const { updated: fileUpdated, changes: fileChanges } = repairDatasourceFile(parsed, {
+        expose: options.expose,
+        sync: options.sync,
+        test: options.test
+      });
+      if (fileUpdated) {
+        updated = true;
+        fileChanges.forEach(c => changes.push(`${fileName}: ${c}`));
+        if (!dryRun) {
+          backupIntegrationFile(filePath, options.backupCtx);
+          writeConfigFile(filePath, parsed);
+        }
+        trackRepairWrite(filePath, options.backupCtx);
+      }
+    } catch (err) {
+      logger.log(chalk.yellow(`⚠ Could not repair datasource ${fileName}: ${err.message}`));
+    }
+  }
+  return updated;
+}
+
+module.exports = {
+  runDatasourceRepairs
+};

package/lib/commands/repair-datasource-test-payload.js

@@ -0,0 +1,259 @@
+/**
+ * Schema-aware testPayload repair (payloadTemplate / expectedResult).
+ *
+ * @fileoverview Helpers for repair-datasource testPayload generation
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {string|string[]|undefined} type - JSON Schema type
+ * @returns {string}
+ */
+function primarySchemaType(type) {
+  if (Array.isArray(type)) {
+    const nonNull = type.filter(t => t !== 'null');
+    return nonNull[0] || 'string';
+  }
+  return type || 'string';
+}
+
+/**
+ * @param {Object|null|undefined} schema - JSON Schema node
+ * @param {string} key - Property name
+ * @returns {Object|null}
+ */
+function getSchemaProperty(schema, key) {
+  if (!schema || typeof schema !== 'object') return null;
+  const props = schema.properties;
+  if (props && typeof props === 'object' && Object.prototype.hasOwnProperty.call(props, key)) {
+    return props[key];
+  }
+  if (schema.additionalProperties === true) {
+    return { type: 'string' };
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+    return schema.additionalProperties;
+  }
+  return null;
+}
+
+/**
+ * @param {Object|null|undefined} rootSchema - metadataSchema root
+ * @param {string[]} pathParts - Dot path under raw payload (no raw. prefix)
+ * @returns {Object|null}
+ */
+function getSchemaNodeAtPath(rootSchema, pathParts) {
+  if (!rootSchema || !pathParts.length) return rootSchema;
+  let node = rootSchema;
+  for (const part of pathParts) {
+    if (!part) continue;
+    const next = getSchemaProperty(node, part);
+    if (!next) return null;
+    node = next;
+  }
+  return node;
+}
+
+/**
+ * @param {Object|null|undefined} node - JSON Schema node
+ * @returns {*}
+ */
+function placeholderFromSchemaNode(node) {
+  if (!node || typeof node !== 'object') return '';
+  const type = primarySchemaType(node.type);
+  if (node.format === 'date-time') return '2025-01-15T10:30:00Z';
+  if (node.format === 'date') return '2025-01-15';
+  if (node.format === 'uuid') return '00000000-0000-4000-8000-000000000001';
+  if (type === 'boolean') return false;
+  if (type === 'integer' || type === 'number') return 0;
+  if (type === 'array') return [];
+  if (type === 'object') {
+    if (node.properties && typeof node.properties === 'object') {
+      const out = {};
+      for (const [k, sub] of Object.entries(node.properties)) {
+        out[k] = placeholderFromSchemaNode(sub);
+      }
+      return out;
+    }
+    return {};
+  }
+  return '';
+}
+
+/**
+ * @param {string} type - Legacy attribute type
+ * @returns {*}
+ */
+function placeholderForType(type) {
+  if (type === 'number' || type === 'integer') return 0;
+  if (type === 'boolean') return false;
+  if (type === 'array') return [];
+  if (type === 'object') return {};
+  return '';
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {string[]} pathParts - Path under raw payload
+ * @param {Object} [attrConfig] - Attribute config (optional type fallback)
+ * @returns {*}
+ */
+function resolvePlaceholderForPath(parsed, pathParts, attrConfig) {
+  const node = getSchemaNodeAtPath(parsed?.metadataSchema, pathParts);
+  if (node) return placeholderFromSchemaNode(node);
+  return placeholderForType(attrConfig?.type || 'string');
+}
+
+/**
+ * @param {Object} obj - Target object (mutated)
+ * @param {string[]} pathParts - Path segments
+ * @param {*} value - Value to set
+ */
+function setNestedValue(obj, pathParts, value) {
+  const parts = pathParts.filter(Boolean);
+  if (!parts.length) return;
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const p = parts[i];
+    if (!(p in cur) || typeof cur[p] !== 'object' || cur[p] === null || Array.isArray(cur[p])) {
+      cur[p] = {};
+    }
+    cur = cur[p];
+  }
+  const last = parts[parts.length - 1];
+  const existing = cur[last];
+  if (
+    existing &&
+    typeof existing === 'object' &&
+    !Array.isArray(existing) &&
+    value &&
+    typeof value === 'object' &&
+    !Array.isArray(value)
+  ) {
+    cur[last] = { ...existing, ...value };
+    return;
+  }
+  cur[last] = value;
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {Array<{ path: string, config: Object }>} pathEntries - Sorted deepest-first
+ * @param {Object} payloadTemplate - payloadTemplate (mutated)
+ */
+function enrichObjectLeavesFromNestedPaths(parsed, pathEntries, payloadTemplate) {
+  const propertiesNode = getSchemaNodeAtPath(parsed?.metadataSchema, ['properties']);
+  for (const { path } of pathEntries) {
+    if (!path.startsWith('properties.')) continue;
+    const leaf = path.slice('properties.'.length);
+    if (!leaf || leaf.includes('.')) continue;
+    if (!payloadTemplate.properties || typeof payloadTemplate.properties !== 'object') {
+      payloadTemplate.properties = placeholderFromSchemaNode(propertiesNode);
+    }
+    if (payloadTemplate.properties[leaf] === undefined || payloadTemplate.properties[leaf] === '') {
+      const leafNode = getSchemaNodeAtPath(parsed?.metadataSchema, ['properties', leaf]);
+      payloadTemplate.properties[leaf] = leafNode
+        ? placeholderFromSchemaNode(leafNode)
+        : 'sample';
+    }
+  }
+}
+
+/**
+ * @param {string} expressionPath - Path from {{ ... }} token
+ * @returns {string|null}
+ */
+function stripExpressionPathPrefix(expressionPath) {
+  const path = expressionPath.trim();
+  if (path.startsWith('raw.')) return path.slice(4);
+  if (path.startsWith('metadata.')) return path.slice(9);
+  return path;
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {Object} attrs - fieldMappings.attributes
+ * @returns {Array<{ attrKey: string, path: string|null, config: Object, expectedOnly: *|null }>}
+ */
+function buildPathEntriesFromAttributes(parsed, attrs) {
+  const pathEntries = [];
+  for (const [attrKey, config] of Object.entries(attrs)) {
+    const match = config?.expression?.match(/\{\{\s*([^}|]+)/);
+    if (!match) {
+      const metaNode = parsed.metadataSchema?.properties?.[attrKey];
+      const expected = metaNode
+        ? placeholderFromSchemaNode(metaNode)
+        : placeholderForType(config?.type || 'string');
+      pathEntries.push({ attrKey, path: null, config, expectedOnly: expected });
+      continue;
+    }
+    pathEntries.push({
+      attrKey,
+      path: stripExpressionPathPrefix(match[1]),
+      config,
+      expectedOnly: null
+    });
+  }
+  return pathEntries.sort((a, b) => {
+    const depthA = a.path ? a.path.split('.').length : 0;
+    const depthB = b.path ? b.path.split('.').length : 0;
+    return depthB - depthA;
+  });
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {Array} pathEntries - From buildPathEntriesFromAttributes
+ * @returns {{ payloadTemplate: Object, expectedResult: Object }}
+ */
+function buildTemplatesFromPathEntries(parsed, pathEntries) {
+  const payloadTemplate = {};
+  const expectedResult = {};
+  for (const entry of pathEntries) {
+    const { attrKey, path, config, expectedOnly } = entry;
+    const metaNode = parsed.metadataSchema?.properties?.[attrKey];
+    expectedResult[attrKey] = metaNode
+      ? placeholderFromSchemaNode(metaNode)
+      : (expectedOnly ?? placeholderForType(config?.type || 'string'));
+    if (!path) continue;
+    const parts = path.split('.');
+    setNestedValue(payloadTemplate, parts, resolvePlaceholderForPath(parsed, parts, config));
+  }
+  enrichObjectLeavesFromNestedPaths(parsed, pathEntries, payloadTemplate);
+  return { payloadTemplate, expectedResult };
+}
+
+/**
+ * Builds minimal payloadTemplate and expectedResult from attributes + metadataSchema.
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Change log
+ * @returns {boolean} True if testPayload was added or updated
+ */
+function repairTestPayload(parsed, changes) {
+  const attrs = parsed?.fieldMappings?.attributes;
+  if (!attrs || typeof attrs !== 'object') return false;
+
+  const pathEntries = buildPathEntriesFromAttributes(parsed, attrs);
+  const { payloadTemplate, expectedResult } = buildTemplatesFromPathEntries(parsed, pathEntries);
+
+  if (!parsed.testPayload) parsed.testPayload = {};
+  parsed.testPayload.payloadTemplate = payloadTemplate;
+  parsed.testPayload.expectedResult = expectedResult;
+  changes.push(
+    'Generated testPayload.payloadTemplate and testPayload.expectedResult from attributes and metadataSchema'
+  );
+  return true;
+}
+
+module.exports = {
+  primarySchemaType,
+  getSchemaNodeAtPath,
+  placeholderFromSchemaNode,
+  placeholderForType,
+  resolvePlaceholderForPath,
+  repairTestPayload
+};

package/lib/commands/repair-datasource.js

@@ -11,6 +11,7 @@
 
 const { repairOpenapiSection } = require('./repair-datasource-openapi');
 const { normalizeAutoRbacOperationKeys } = require('./repair-datasource-auto-rbac');
+const { repairTestPayload } = require('./repair-datasource-test-payload');
 
 const DEFAULT_SYNC = {
   mode: 'pull',
@@ -358,25 +359,6 @@ function repairSyncSection(parsed, changes) {
   return true;
 }
 
-function placeholderForType(type) {
-  if (type === 'number' || type === 'integer') return 0;
-  if (type === 'boolean') return false;
-  if (type === 'array') return [];
-  if (type === 'object') return {};
-  return '';
-}
-
-function setNested(obj, pathParts, value) {
-  let cur = obj;
-  for (let i = 0; i < pathParts.length - 1; i++) {
-    const p = pathParts[i];
-    if (!(p in cur) || typeof cur[p] !== 'object') cur[p] = {};
-    cur = cur[p];
-  }
-  const last = pathParts[pathParts.length - 1];
-  if (last) cur[last] = value;
-}
-
 /**
  * Removes unknown top-level keys from testPayload (v2.4.1 closed root).
  * @param {Object} parsed - Parsed datasource (mutated)
@@ -398,38 +380,6 @@ function sanitizeTestPayloadTopLevel(parsed, changes) {
   return true;
 }
 
-/**
- * Builds minimal payloadTemplate and expectedResult from attribute expression paths.
- *
- * @param {Object} parsed - Parsed datasource (mutated)
- * @param {string[]} changes - Change log
- * @returns {boolean} True if testPayload was added or updated
- */
-function repairTestPayload(parsed, changes) {
-  const attrs = parsed?.fieldMappings?.attributes;
-  if (!attrs || typeof attrs !== 'object') return false;
-  const payloadTemplate = {};
-  const expectedResult = {};
-  for (const [key, config] of Object.entries(attrs)) {
-    const type = config?.type || 'string';
-    const placeholder = placeholderForType(type);
-    expectedResult[key] = placeholder;
-    const match = config?.expression?.match(/\{\{\s*([^}|]+)/);
-    if (match) {
-      let path = match[1].trim();
-      if (path.startsWith('raw.')) {
-        path = path.slice(4);
-      }
-      setNested(payloadTemplate, path.split('.'), placeholder);
-    }
-  }
-  if (!parsed.testPayload) parsed.testPayload = {};
-  parsed.testPayload.payloadTemplate = payloadTemplate;
-  parsed.testPayload.expectedResult = expectedResult;
-  changes.push('Generated testPayload.payloadTemplate and testPayload.expectedResult from attributes');
-  return true;
-}
-
 /**
  * Runs all requested datasource repairs.
  *