@aifabrix/builder 2.49.2 → 2.51.0

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

@@ -0,0 +1,156 @@
+/**
+ * Export full programmatic OpenAPI (components + request/response schemas) for repair --api.
+ *
+ * @fileoverview Materialize integration/<systemKey>/openapi/*.json from buildOpenApiSpec
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+const { buildOpenApiSpec } = require('../programmatic/openapi-spec');
+const { loadConfigFile } = require('../utils/config-format');
+const { backupIntegrationFile } = require('../utils/integration-file-backup');
+const { trackRepairWrite } = require('./repair-changed-files');
+
+/**
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {string} documentKey
+ * @returns {string}
+ */
+function documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey) {
+  const openapiDir = path.join(appPath, 'openapi');
+  const suffix = documentKey.startsWith(`${systemKey}-`)
+    ? documentKey.slice(systemKey.length + 1)
+    : documentKey;
+  return path.join(openapiDir, `${suffix}.json`);
+}
+
+/** @type {Set<string>} */
+const PROGRAMMATIC_ORCHESTRATION_SYSTEM_KEYS = new Set(['builder-api']);
+
+/**
+ * @param {string} systemKey
+ * @returns {boolean}
+ */
+function isProgrammaticOrchestrationSystem(systemKey) {
+  return PROGRAMMATIC_ORCHESTRATION_SYSTEM_KEYS.has(String(systemKey || '').trim());
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} fileName
+ * @returns {string|null}
+ */
+function readDatasourceDocumentKey(appPath, fileName) {
+  const dsPath = path.join(appPath, fileName);
+  if (!fs.existsSync(dsPath)) {
+    return null;
+  }
+  const parsed = loadConfigFile(dsPath);
+  const openapi = parsed && typeof parsed.openapi === 'object' && !Array.isArray(parsed.openapi) ? parsed.openapi : null;
+  return openapi && typeof openapi.documentKey === 'string' ? openapi.documentKey.trim() : null;
+}
+
+/**
+ * @param {string} appPath
+ * @param {string[]} datasourceFiles
+ * @returns {string|null}
+ */
+function resolveSharedDocumentKey(appPath, datasourceFiles) {
+  const keys = new Set();
+  for (const fileName of datasourceFiles || []) {
+    const dk = readDatasourceDocumentKey(appPath, fileName);
+    if (dk) {
+      keys.add(dk);
+    }
+  }
+  if (keys.size === 1) {
+    return [...keys][0];
+  }
+  return null;
+}
+
+/**
+ * @param {Object} spec
+ * @returns {boolean}
+ */
+function specHasComponentSchemas(spec) {
+  const schemas = spec && spec.components && spec.components.schemas;
+  return Boolean(schemas && typeof schemas === 'object' && Object.keys(schemas).length > 0);
+}
+
+/**
+ * @param {string} localPath
+ * @param {Object} spec
+ * @param {boolean} dryRun
+ * @param {Object} backupCtx
+ * @returns {Promise<void>}
+ */
+async function writeOpenApiSpecToDisk(localPath, spec, dryRun, backupCtx) {
+  if (dryRun) {
+    return;
+  }
+  const openapiDir = path.dirname(localPath);
+  fs.mkdirSync(openapiDir, { recursive: true });
+  if (fs.existsSync(localPath)) {
+    backupIntegrationFile(localPath, backupCtx);
+  }
+  fs.writeFileSync(localPath, `${JSON.stringify(spec, null, 2)}\n`, 'utf8');
+  trackRepairWrite(localPath, backupCtx);
+}
+
+/**
+ * @param {string} localPath
+ * @param {Object} spec
+ * @returns {string}
+ */
+function formatOpenApiExportSummary(localPath, spec) {
+  const rel = path.relative(process.cwd(), localPath);
+  return (
+    `Exported full OpenAPI (${Object.keys(spec.paths || {}).length} paths, `
+    + `${Object.keys(spec.components.schemas || {}).length} schemas) to ${rel}`
+  );
+}
+
+/**
+ * @param {Object} opts
+ * @param {string} opts.appPath
+ * @param {string} opts.systemKey
+ * @param {string[]} opts.datasourceFiles
+ * @param {boolean} opts.dryRun
+ * @param {Object} opts.backupCtx
+ * @returns {Promise<string[]>}
+ */
+async function exportProgrammaticOpenApiForRepair(opts) {
+  const { appPath, systemKey, datasourceFiles, dryRun, backupCtx } = opts;
+  const lines = [];
+  if (!isProgrammaticOrchestrationSystem(systemKey)) {
+    return lines;
+  }
+  const documentKey = resolveSharedDocumentKey(appPath, datasourceFiles);
+  if (!documentKey) {
+    lines.push('Skipped OpenAPI export: datasources do not share a single openapi.documentKey');
+    return lines;
+  }
+  const localPath = documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey);
+  const spec = buildOpenApiSpec();
+  if (!specHasComponentSchemas(spec)) {
+    lines.push('Skipped OpenAPI export: programmatic buildOpenApiSpec() has no component schemas');
+    return lines;
+  }
+  await writeOpenApiSpecToDisk(localPath, spec, dryRun, backupCtx);
+  lines.push(formatOpenApiExportSummary(localPath, spec));
+  return lines;
+}
+
+module.exports = {
+  documentKeyToLocalOpenApiPath,
+  exportProgrammaticOpenApiForRepair,
+  isProgrammaticOrchestrationSystem,
+  resolveSharedDocumentKey,
+  specHasComponentSchemas
+};

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

@@ -24,6 +24,7 @@ const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
 const { uploadFileAs } = require('../utils/file-upload');
 const { listOpenAPIFiles } = require('../api/external-systems.api');
 const { resolveLabDataplaneApiKey } = require('../utils/credential-secrets-env');
+const { exportProgrammaticOpenApiForRepair } = require('./repair-openapi-export');
 
 async function fileExistsAsync(filePath) {
   try {
@@ -96,7 +97,7 @@ function extractOpenApiFileListItems(res) {
   const data = res && res.data;
   if (data && Array.isArray(data.data)) return data.data;
   if (data && Array.isArray(data.items)) return data.items;
-  if (res && Array.isArray(res.items)) return res.items;
+  if (Array.isArray(res.items)) return res.items;
   return [];
 }
 
@@ -139,13 +140,15 @@ async function syncOpenApiFilesForMcp(opts) {
     authConfig: opts.authConfig
   });
   const existingKeys = await getExistingOpenApiKeys(dataplaneUrl, systemKey, authConfig);
-  const uploadedKeys = new Set(existingKeys);
+  const uploadedThisRun = new Set();
   let uploaded = 0;
   let skipped = 0;
+  const forceUpload = opts.force === true;
 
   for (const fileName of datasourceFiles || []) {
     const documentKey = readDatasourceDocumentKey(appPath, fileName);
-    if (!documentKey || uploadedKeys.has(documentKey)) continue;
+    if (!documentKey || uploadedThisRun.has(documentKey)) continue;
+    if (!forceUpload && existingKeys.has(documentKey)) continue;
 
     const localPath = documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey);
     if (!(await fileExistsAsync(localPath))) {
@@ -154,7 +157,7 @@ async function syncOpenApiFilesForMcp(opts) {
     }
 
     await uploadOneOpenApiFile(dataplaneUrl, authConfig, systemKey, localPath, documentKey);
-    uploadedKeys.add(documentKey);
+    uploadedThisRun.add(documentKey);
     uploaded += 1;
   }
 
@@ -176,7 +179,11 @@ async function maybeSyncOpenApiFilesForMcp(opts) {
   const r = await syncOpenApiFilesForMcp(opts);
   const lines = [];
   if (r.uploaded > 0) {
-    lines.push(`Uploaded ${r.uploaded} OpenAPI file(s) for MCP (keyed by openapi.documentKey)`);
+    lines.push(
+      opts.force
+        ? `Uploaded ${r.uploaded} OpenAPI file(s) for MCP (force replace by openapi.documentKey)`
+        : `Uploaded ${r.uploaded} OpenAPI file(s) for MCP (keyed by openapi.documentKey)`
+    );
   }
   if (r.skipped > 0) {
     lines.push(
@@ -190,18 +197,36 @@ async function maybeSyncOpenApiFilesForMcp(opts) {
  * @param {Object} args
  * @returns {Promise<boolean>}
  */
-async function maybeRunOpenApiSyncForMcp({ options, dryRun, appPath, systemKey, datasourceFiles, changes }) {
+async function maybeRunOpenApiSyncForMcp({
+  options,
+  dryRun,
+  appPath,
+  systemKey,
+  datasourceFiles,
+  changes,
+  backupCtx
+}) {
   if (!options.api) return false;
   try {
+    const exportLines = await exportProgrammaticOpenApiForRepair({
+      appPath,
+      systemKey,
+      datasourceFiles,
+      dryRun,
+      backupCtx
+    });
+    exportLines.forEach((line) => changes.push(line));
     const openapiLines = await maybeSyncOpenApiFilesForMcp({
       enabled: true,
       dryRun,
       appPath,
       systemKey,
-      datasourceFiles
+      datasourceFiles,
+      // --api re-exports local OpenAPI; always replace SpecFile rows that already exist.
+      force: true
     });
     openapiLines.forEach((l) => changes.push(l));
-    return openapiLines.length > 0;
+    return exportLines.length > 0 || openapiLines.length > 0;
   } catch (err) {
     changes.push(`OpenAPI upload for MCP failed: ${err.message}`);
     return false;

package/lib/commands/repair-orchestration-datasource-split.js

@@ -0,0 +1,259 @@
+/**
+ * Split monolithic orchestration datasource into per-OpenAPI-tag datasources (plan 154.7).
+ *
+ * @fileoverview repair-orchestration-datasource-split
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { CAPABILITIES } = require('../programmatic/capability-registry');
+const { buildOperationXAfabrix, resolveTagCatalogEntry } = require('../programmatic/orchestration-openapi-meta');
+const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
+const { backupIntegrationFile } = require('../utils/integration-file-backup');
+const { trackRepairWrite } = require('./repair-changed-files');
+
+/**
+ * @returns {Map<string, string>}
+ */
+function buildHandlerIdToTagMap() {
+  /** @type {Map<string, string>} */
+  const map = new Map();
+  for (const capability of CAPABILITIES) {
+    map.set(capability.handlerId, buildOperationXAfabrix(capability).datasourceTag);
+  }
+  return map;
+}
+
+/**
+ * @param {Object} parsed
+ * @param {Map<string, string>} handlerToTag
+ * @returns {Map<string, string>}
+ */
+function buildManifestKeyToTagMap(parsed, handlerToTag) {
+  /** @type {Map<string, string>} */
+  const keyToTag = new Map();
+  const ops = parsed?.openapi?.operations;
+  if (!ops || typeof ops !== 'object') {
+    return keyToTag;
+  }
+  for (const [manifestKey, entry] of Object.entries(ops)) {
+    if (!entry || typeof entry !== 'object') {
+      continue;
+    }
+    const opId = entry.operationId;
+    const tag = typeof opId === 'string' ? handlerToTag.get(opId) : undefined;
+    if (tag) {
+      keyToTag.set(manifestKey, tag);
+      keyToTag.set(manifestKey.toLowerCase(), tag);
+    }
+  }
+  return keyToTag;
+}
+
+/**
+ * @param {Object|undefined} block
+ * @param {Set<string>} keys
+ * @returns {Object}
+ */
+function pickOperationMap(block, keys) {
+  if (!block || typeof block !== 'object') {
+    return {};
+  }
+  /** @type {Object} */
+  const picked = {};
+  for (const [opKey, value] of Object.entries(block)) {
+    const normalized = String(opKey).toLowerCase();
+    if (keys.has(opKey) || keys.has(normalized)) {
+      picked[opKey] = value;
+    }
+  }
+  return picked;
+}
+
+/**
+ * @param {Object} parsed
+ * @param {string} tag
+ * @param {Set<string>} keys
+ * @param {string} systemKey
+ * @returns {Object}
+ */
+function buildTagDatasource(parsed, tag, keys, systemKey) {
+  const catalog = resolveTagCatalogEntry(tag);
+  const key = `${systemKey}-${tag}`;
+  const capabilities = Array.isArray(parsed.capabilities)
+    ? parsed.capabilities.filter((row) => {
+      if (!row || !row.key) {
+        return false;
+      }
+      const rowKey = String(row.key).toLowerCase();
+      return [...keys].some((key) => String(key).toLowerCase() === rowKey);
+    })
+    : [];
+  const openapiOps = pickOperationMap(parsed.openapi?.operations, keys);
+  const cipOps = pickOperationMap(parsed.execution?.cip?.operations, keys);
+  const mcpTools = pickOperationMap(parsed.mcpContract?.tools, keys);
+  return {
+    ...parsed,
+    key,
+    displayName: `${catalog.displayName} operations`,
+    resourceType: catalog.resourceType,
+    description: `${catalog.displayName} operations from ${systemKey} via orchestration-api`,
+    capabilities,
+    openapi: {
+      ...(parsed.openapi || {}),
+      operations: openapiOps
+    },
+    execution: {
+      ...(parsed.execution || {}),
+      cip: {
+        ...(parsed.execution?.cip || {}),
+        operations: cipOps
+      }
+    },
+    mcpContract: parsed.mcpContract
+      ? {
+        ...parsed.mcpContract,
+        tools: mcpTools
+      }
+      : parsed.mcpContract
+  };
+}
+
+/**
+ * @param {string} fileName
+ * @returns {boolean}
+ */
+function isMonolithicOperationsDatasource(fileName) {
+  return /-datasource-operations\.(json|ya?ml)$/i.test(fileName);
+}
+
+/**
+ * @param {Map<string, string>} keyToTag
+ * @returns {Map<string, Set<string>>}
+ */
+function groupManifestKeysByTag(keyToTag) {
+  /** @type {Map<string, Set<string>>} */
+  const tagBuckets = new Map();
+  for (const [manifestKey, tag] of keyToTag.entries()) {
+    const bucket = tagBuckets.get(tag) || new Set();
+    bucket.add(manifestKey);
+    tagBuckets.set(tag, bucket);
+  }
+  return tagBuckets;
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} monolithFile
+ * @returns {{ monolithPath: string, parsed: Object, tagBuckets: Map<string, Set<string>> }|null}
+ */
+function loadMonolithSplitContext(appPath, monolithFile) {
+  const monolithPath = path.join(appPath, monolithFile);
+  if (!fs.existsSync(monolithPath)) {
+    return null;
+  }
+  const parsed = loadConfigFile(monolithPath);
+  const keyToTag = buildManifestKeyToTagMap(parsed, buildHandlerIdToTagMap());
+  if (keyToTag.size === 0) {
+    return null;
+  }
+  const tagBuckets = groupManifestKeysByTag(keyToTag);
+  if (tagBuckets.size <= 1) {
+    return null;
+  }
+  return { monolithPath, parsed, tagBuckets };
+}
+
+/**
+ * @param {Object} params
+ * @returns {string[]}
+ */
+function writeSplitTagDatasources(params) {
+  const { appPath, systemKey, monolithFile, parsed, tagBuckets, options, dryRun, changes } = params;
+  const newFiles = [];
+  for (const [tag, keys] of [...tagBuckets.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const fileName = `${systemKey}-datasource-${tag}.json`;
+    newFiles.push(fileName);
+    changes.push(`Split ${monolithFile} → ${fileName} (${keys.size} operations)`);
+    if (dryRun) {
+      continue;
+    }
+    const outPath = path.join(appPath, fileName);
+    backupIntegrationFile(outPath, options.backupCtx);
+    writeConfigFile(outPath, buildTagDatasource(parsed, tag, keys, systemKey));
+    trackRepairWrite(outPath, options.backupCtx);
+  }
+  return newFiles;
+}
+
+/**
+ * @param {Object} params
+ */
+function removeMonolithDatasource(params) {
+  const { monolithPath, monolithFile, options, dryRun, changes } = params;
+  changes.push(`Remove monolithic datasource ${monolithFile}`);
+  if (dryRun) {
+    return;
+  }
+  backupIntegrationFile(monolithPath, options.backupCtx);
+  fs.unlinkSync(monolithPath);
+  trackRepairWrite(monolithPath, options.backupCtx);
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {string[]} datasourceFiles
+ * @param {Object} options
+ * @param {boolean} dryRun
+ * @param {string[]} changes
+ * @returns {{ updated: boolean, datasourceFiles: string[] }}
+ */
+function repairSplitOrchestrationDatasources(
+  appPath,
+  systemKey,
+  datasourceFiles,
+  options,
+  dryRun,
+  changes
+) {
+  if (!options.splitDatasources) {
+    return { updated: false, datasourceFiles };
+  }
+  const monolithFile = datasourceFiles.find(isMonolithicOperationsDatasource);
+  if (!monolithFile) {
+    return { updated: false, datasourceFiles };
+  }
+  const splitCtx = loadMonolithSplitContext(appPath, monolithFile);
+  if (!splitCtx) {
+    return { updated: false, datasourceFiles };
+  }
+  const newFiles = writeSplitTagDatasources({
+    appPath,
+    systemKey,
+    monolithFile,
+    parsed: splitCtx.parsed,
+    tagBuckets: splitCtx.tagBuckets,
+    options,
+    dryRun,
+    changes
+  });
+  removeMonolithDatasource({
+    monolithPath: splitCtx.monolithPath,
+    monolithFile,
+    options,
+    dryRun,
+    changes
+  });
+  const remaining = datasourceFiles.filter((f) => f !== monolithFile).concat(newFiles);
+  return { updated: true, datasourceFiles: remaining };
+}
+
+module.exports = {
+  repairSplitOrchestrationDatasources,
+  isMonolithicOperationsDatasource
+};

package/lib/commands/repair-persist.js

@@ -21,6 +21,7 @@ const { trackRepairWrite } = require('./repair-changed-files');
 const logger = require('../utils/logger');
 const generator = require('../generator');
 const { generateReadmeFromDeployJson } = require('../generator/split-readme');
+const { regenerateDeployScriptFromIntegration } = require('../generator/deploy-script');
 
 /**
  * README "Files" section should match integration config format on disk (YAML vs JSON).
@@ -38,6 +39,25 @@ function inferExternalReadmeFileExt(appPath) {
   return '.json';
 }
 
+async function regenerateDeployScript(appPath, systemKey, systemFiles, datasourceFiles, changes, backupCtx) {
+  try {
+    const deployPath = path.join(appPath, 'deploy.js');
+    trackRepairWrite(deployPath, backupCtx);
+    backupIntegrationFile(deployPath, backupCtx);
+    await regenerateDeployScriptFromIntegration({
+      appPath,
+      systemKey,
+      systemFiles,
+      datasourceFiles
+    });
+    changes.push('Regenerated deploy.js');
+    return true;
+  } catch (err) {
+    logger.log(chalk.yellow(`⚠ deploy.js regeneration skipped: ${err.message}`));
+    return false;
+  }
+}
+
 async function regenerateManifest(appName, appPath, changes, backupCtx) {
   try {
     const deployPath = getDeployJsonPath(appName, 'external', true);
@@ -101,6 +121,7 @@ function persistChangesAndRegenerate(opts) {
 
 module.exports = {
   persistChangesAndRegenerate,
-  regenerateReadmeIfRequested
+  regenerateReadmeIfRequested,
+  regenerateDeployScript
 };