@aifabrix/builder 2.50.0 → 2.51.1

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

@@ -57,30 +57,51 @@ function getSchemaNodeAtPath(rootSchema, pathParts) {
   return node;
 }
 
+/**
+ * Format / pattern samples for string-like schema nodes.
+ * @param {Object} node - JSON Schema node
+ * @returns {*|undefined}
+ */
+function placeholderFromFormatOrPattern(node) {
+  const samples = {
+    'date-time': '2025-01-15T10:30:00Z',
+    date: '2025-01-15',
+    uuid: '00000000-0000-4000-8000-000000000001',
+    uri: 'https://example.com/objects/1',
+    'uri-reference': 'https://example.com/objects/1',
+    email: 'sample@example.com'
+  };
+  if (node.format && Object.prototype.hasOwnProperty.call(samples, node.format)) {
+    return samples[node.format];
+  }
+  if (typeof node.pattern === 'string' && /\\d/.test(node.pattern)) {
+    return '+1 555 0100';
+  }
+  return undefined;
+}
+
 /**
  * @param {Object|null|undefined} node - JSON Schema node
  * @returns {*}
  */
 function placeholderFromSchemaNode(node) {
-  if (!node || typeof node !== 'object') return '';
+  if (!node || typeof node !== 'object') return 'sample';
+  const fromFormat = placeholderFromFormatOrPattern(node);
+  if (fromFormat !== undefined) return fromFormat;
   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;
+    const props = node.properties;
+    if (!props || typeof props !== 'object') return {};
+    const out = {};
+    for (const [k, sub] of Object.entries(props)) {
+      out[k] = placeholderFromSchemaNode(sub);
     }
-    return {};
+    return out;
   }
-  return '';
+  return 'sample';
 }
 
 /**
@@ -92,18 +113,35 @@ function placeholderForType(type) {
   if (type === 'boolean') return false;
   if (type === 'array') return [];
   if (type === 'object') return {};
-  return '';
+  return 'sample';
 }
 
 /**
- * @param {Object} parsed - Datasource config
- * @param {string[]} pathParts - Path under raw payload
- * @param {Object} [attrConfig] - Attribute config (optional type fallback)
- * @returns {*}
+ * Prefer schema nodes that carry format/pattern over bare type-only nodes.
+ * @param {Object|null|undefined} a
+ * @param {Object|null|undefined} b
+ * @returns {Object|null}
  */
+function pickRicherSchemaNode(a, b) {
+  const score = node => {
+    if (!node || typeof node !== 'object') return -1;
+    let s = 0;
+    if (node.format) s += 2;
+    if (node.pattern) s += 2;
+    if (node.type) s += 1;
+    return s;
+  };
+  if (score(a) < 0 && score(b) < 0) return null;
+  return score(a) >= score(b) ? a : b;
+}
+
 function resolvePlaceholderForPath(parsed, pathParts, attrConfig) {
   const node = getSchemaNodeAtPath(parsed?.metadataSchema, pathParts);
-  if (node) return placeholderFromSchemaNode(node);
+  // HubSpot-style: materialized root prop (phone/email/url) may be richer than nested.
+  const leaf = pathParts[pathParts.length - 1];
+  const rootNode = parsed?.metadataSchema?.properties?.[leaf];
+  const picked = pickRicherSchemaNode(node, rootNode);
+  if (picked) return placeholderFromSchemaNode(picked);
   return placeholderForType(attrConfig?.type || 'string');
 }
 
@@ -154,7 +192,10 @@ function enrichObjectLeavesFromNestedPaths(parsed, pathEntries, payloadTemplate)
       payloadTemplate.properties = placeholderFromSchemaNode(propertiesNode);
     }
     if (payloadTemplate.properties[leaf] === undefined || payloadTemplate.properties[leaf] === '') {
-      const leafNode = getSchemaNodeAtPath(parsed?.metadataSchema, ['properties', leaf]);
+      const leafNode = pickRicherSchemaNode(
+        getSchemaNodeAtPath(parsed?.metadataSchema, ['properties', leaf]),
+        parsed?.metadataSchema?.properties?.[leaf]
+      );
       payloadTemplate.properties[leaf] = leafNode
         ? placeholderFromSchemaNode(leafNode)
         : 'sample';
@@ -209,6 +250,24 @@ function buildPathEntriesFromAttributes(parsed, attrs) {
  * @param {Array} pathEntries - From buildPathEntriesFromAttributes
  * @returns {{ payloadTemplate: Object, expectedResult: Object }}
  */
+/**
+ * Ensure metadataSchema.required root keys exist on payloadTemplate.
+ * @param {Object} parsed
+ * @param {Object} payloadTemplate
+ */
+function ensureRequiredRootPlaceholders(parsed, payloadTemplate) {
+  const required = parsed?.metadataSchema?.required;
+  const props = parsed?.metadataSchema?.properties;
+  if (!Array.isArray(required) || !props || typeof props !== 'object') return;
+  for (const key of required) {
+    if (!key || typeof key !== 'string') continue;
+    const existing = payloadTemplate[key];
+    if (existing !== undefined && existing !== '') continue;
+    const node = props[key];
+    payloadTemplate[key] = node ? placeholderFromSchemaNode(node) : 'sample';
+  }
+}
+
 function buildTemplatesFromPathEntries(parsed, pathEntries) {
   const payloadTemplate = {};
   const expectedResult = {};
@@ -223,6 +282,7 @@ function buildTemplatesFromPathEntries(parsed, pathEntries) {
     setNestedValue(payloadTemplate, parts, resolvePlaceholderForPath(parsed, parts, config));
   }
   enrichObjectLeavesFromNestedPaths(parsed, pathEntries, payloadTemplate);
+  ensureRequiredRootPlaceholders(parsed, payloadTemplate);
   return { payloadTemplate, expectedResult };
 }
 
@@ -255,5 +315,6 @@ module.exports = {
   placeholderFromSchemaNode,
   placeholderForType,
   resolvePlaceholderForPath,
+  ensureRequiredRootPlaceholders,
   repairTestPayload
 };

package/lib/commands/repair-datasource-webhooks-sync-bridge.js

@@ -88,21 +88,59 @@ function ensureSyncBridgeExternalIdMetadata(parsed, changes) {
   return true;
 }
 
+/**
+ * Default syncBridge when --sync repair runs and the field is absent.
+ * Explicit values (including disabled) are never overwritten.
+ *
+ * @param {object} parsed
+ * @param {Object} [options]
+ * @returns {'master' | 'disabled' | null}
+ */
+function defaultSyncBridgeForSyncRepair(parsed, options = {}) {
+  if (options.sync !== true) {
+    return null;
+  }
+  if (Object.prototype.hasOwnProperty.call(parsed || {}, 'syncBridge')) {
+    return null;
+  }
+  const entityType = String(parsed?.entityType || '').trim();
+  if (entityType === 'none') {
+    return null;
+  }
+  const resourceType = String(parsed?.resourceType || '').trim();
+  // Owner/employee catalogs typically do not own sync propagation.
+  if (resourceType === 'employee') {
+    return 'disabled';
+  }
+  if (entityType === 'recordStorage' || entityType === '') {
+    return 'master';
+  }
+  return null;
+}
+
 /**
  * @param {object} parsed
  * @param {string[]} changes
  * @param {string[]} warnings
+ * @param {Object} [options]
  * @returns {boolean}
  */
-function repairSyncBridgeSection(parsed, changes, warnings) {
+function repairSyncBridgeSection(parsed, changes, warnings, options = {}) {
+  let updated = false;
+  const seeded = defaultSyncBridgeForSyncRepair(parsed, options);
+  if (seeded) {
+    parsed.syncBridge = seeded;
+    changes.push(`Set syncBridge default ${seeded} (--sync repair; field was absent)`);
+    updated = true;
+  }
   const mode = parsed?.syncBridge || 'disabled';
   if (mode === 'disabled') {
-    return false;
+    return updated;
   }
   if (mode === 'master' && !parsed.resourceType) {
     warnings.push('syncBridge=master requires resourceType for propagation grouping.');
   }
-  return ensureSyncBridgeExternalIdMetadata(parsed, changes);
+  return ensureSyncBridgeExternalIdMetadata(parsed, changes) || updated;
 }
 
 /**
@@ -128,6 +166,7 @@ function collectWebhookSyncBridgeSystemWarnings(parsed, systemParsed, warnings)
 module.exports = {
   repairWebhookSection,
   repairSyncBridgeSection,
+  defaultSyncBridgeForSyncRepair,
   collectWebhookSyncBridgeSystemWarnings,
   systemHasWebhookInboundAuth
 };

package/lib/commands/repair-internal.js

@@ -28,7 +28,15 @@ function discoverIntegrationFiles(appPath) {
   if (!fs.existsSync(appPath)) {
     return { systemFiles: [], datasourceFiles: [] };
   }
-  const entries = fs.readdirSync(appPath);
+  let entries = [];
+  try {
+    entries = fs.readdirSync(appPath);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { systemFiles: [], datasourceFiles: [] };
+    }
+    throw error;
+  }
   const systemFiles = [];
   const datasourceFiles = [];
   for (const name of entries) {

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

@@ -30,7 +30,7 @@ function documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey) {
 }
 
 /** @type {Set<string>} */
-const PROGRAMMATIC_ORCHESTRATION_SYSTEM_KEYS = new Set(['aifabrix-builder-api']);
+const PROGRAMMATIC_ORCHESTRATION_SYSTEM_KEYS = new Set(['builder-api']);
 
 /**
  * @param {string} systemKey

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

@@ -97,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 [];
 }
 
@@ -123,6 +123,28 @@ function readDatasourceDocumentKey(appPath, datasourceFileName) {
   return openapi && typeof openapi.documentKey === 'string' ? openapi.documentKey : null;
 }
 
+/**
+ * @returns {Promise<'uploaded'|'skipped'|'skip'>}
+ */
+async function syncOneDatasourceOpenApiFile(ctx, fileName) {
+  const documentKey = readDatasourceDocumentKey(ctx.appPath, fileName);
+  if (!documentKey || ctx.uploadedThisRun.has(documentKey)) return 'skip';
+  if (!ctx.forceUpload && ctx.existingKeys.has(documentKey)) return 'skip';
+
+  const localPath = documentKeyToLocalOpenApiPath(ctx.appPath, ctx.systemKey, documentKey);
+  if (!(await fileExistsAsync(localPath))) return 'skipped';
+
+  await uploadOneOpenApiFile(
+    ctx.dataplaneUrl,
+    ctx.authConfig,
+    ctx.systemKey,
+    localPath,
+    documentKey
+  );
+  ctx.uploadedThisRun.add(documentKey);
+  return 'uploaded';
+}
+
 /**
  * @param {Object} opts
  * @param {string} opts.appPath
@@ -139,24 +161,21 @@ async function syncOpenApiFilesForMcp(opts) {
     dataplaneUrl: opts.dataplaneUrl,
     authConfig: opts.authConfig
   });
-  const existingKeys = await getExistingOpenApiKeys(dataplaneUrl, systemKey, authConfig);
-  const uploadedKeys = new Set(existingKeys);
+  const ctx = {
+    appPath,
+    systemKey,
+    dataplaneUrl,
+    authConfig,
+    existingKeys: await getExistingOpenApiKeys(dataplaneUrl, systemKey, authConfig),
+    uploadedThisRun: new Set(),
+    forceUpload: opts.force === true
+  };
   let uploaded = 0;
   let skipped = 0;
-
   for (const fileName of datasourceFiles || []) {
-    const documentKey = readDatasourceDocumentKey(appPath, fileName);
-    if (!documentKey || uploadedKeys.has(documentKey)) continue;
-
-    const localPath = documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey);
-    if (!(await fileExistsAsync(localPath))) {
-      skipped += 1;
-      continue;
-    }
-
-    await uploadOneOpenApiFile(dataplaneUrl, authConfig, systemKey, localPath, documentKey);
-    uploadedKeys.add(documentKey);
-    uploaded += 1;
+    const outcome = await syncOneDatasourceOpenApiFile(ctx, fileName);
+    if (outcome === 'uploaded') uploaded += 1;
+    if (outcome === 'skipped') skipped += 1;
   }
 
   return { uploaded, skipped };
@@ -177,7 +196,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(
@@ -215,7 +238,9 @@ async function maybeRunOpenApiSyncForMcp({
       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 exportLines.length > 0 || openapiLines.length > 0;

package/lib/commands/resource-type.js

@@ -2,10 +2,7 @@
  * Resource type catalog commands (Controller).
  *
  * Commands:
- * - aifabrix resource-type create
- * - aifabrix resource-type import
- * - aifabrix resource-type get
- * - aifabrix resource-type list
+ * - aifabrix resource-type create|import|export|get|list
  *
  * @fileoverview Resource type CLI commands
  * @author AI Fabrix Team
@@ -21,7 +18,9 @@ const { normalizeControllerUrl, resolveEnvironment } = require('../core/config')
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
 const {
   readResourceTypeCreateFile,
-  readResourceTypeCatalogFile
+  readResourceTypeCatalogFile,
+  mapResourceTypeApiToFileRow,
+  writeResourceTypeCatalogFile
 } = require('../resolvers/resource-type-file');
 const {
   formatBlockingError,
@@ -41,45 +40,43 @@ const RESOURCE_TYPE_KEY_PATTERN = /^[a-z][a-z0-9-]*$/;
 const RESOURCE_TYPE_HELP_AFTER = `
 
 Examples:
-  $ aifabrix resource-type create --key customer --display-name "Customer"
+  $ aifabrix resource-type create --key customer --display-name "Customer" --domain sales
   $ aifabrix resource-type get customer
   $ aifabrix resource-type list --search customer
+  $ aifabrix resource-type export --file ./resource-types-export.json
 
 Per-command help:  aifabrix resource-type <command> --help
 `;
 
 const RESOURCE_TYPE_IMPORT_HELP_AFTER = `
-
 Examples:
   $ aifabrix resource-type import --file ./baseline-resourcetypes.json
   $ aifabrix resource-type import --file /path/to/catalog.json
+`;
 
+const RESOURCE_TYPE_EXPORT_HELP_AFTER = `
+Examples:
+  $ aifabrix resource-type export --file ./resource-types-export.json
 `;
 
 const RESOURCE_TYPE_CREATE_HELP_AFTER = `
-
 Examples:
-  $ aifabrix resource-type create --key customer --display-name "Customer"
+  $ aifabrix resource-type create --key customer --display-name "Customer" --domain sales
   $ aifabrix resource-type create --key deal --display-name "Deal" --category business --default-risk-level medium --domain sales
   $ aifabrix resource-type create --file ./customer.json
-
 `;
 
 const RESOURCE_TYPE_GET_HELP_AFTER = `
-
 Examples:
   $ aifabrix resource-type get customer
   $ aifabrix resource-type get clx1234567890abcdef
-
 `;
 
 const RESOURCE_TYPE_LIST_HELP_AFTER = `
-
 Examples:
   $ aifabrix resource-type list
   $ aifabrix resource-type list --page 1 --page-size 50
   $ aifabrix resource-type list --search customer
-
 `;
 
 /**
@@ -165,8 +162,62 @@ function unwrapControllerData(response) {
 }
 
 /**
- * @param {import('commander').Command} rt
+ * @param {Object|null|undefined} response
+ * @param {string} label
+ * @returns {void}
+ */
+function assertControllerListSuccess(response, label) {
+  if (response && response.success !== false) {
+    return;
+  }
+  const message =
+    response?.formattedError || response?.error || `Failed to list ${label}`;
+  throw new Error(message);
+}
+
+/**
+ * @param {Object} response
+ * @returns {Object[]}
  */
+function extractControllerListItems(response) {
+  if (response?.data && Array.isArray(response.data.data)) {
+    return response.data.data;
+  }
+  const unwrapped = unwrapControllerData(response);
+  if (Array.isArray(unwrapped)) {
+    return unwrapped;
+  }
+  if (unwrapped && Array.isArray(unwrapped.data)) {
+    return unwrapped.data;
+  }
+  throw new Error('Unexpected list response from controller');
+}
+
+/**
+ * @param {string} controllerUrl
+ * @param {Object} authConfig
+ * @returns {Promise<Object[]>}
+ */
+async function fetchAllResourceTypes(controllerUrl, authConfig) {
+  const all = [];
+  let page = 1;
+  const pageSize = 100;
+  for (;;) {
+    const res = await listResourceTypes(controllerUrl, authConfig, { page, pageSize });
+    assertControllerListSuccess(res, 'resource types');
+    const items = extractControllerListItems(res);
+    if (items.length === 0) {
+      break;
+    }
+    all.push(...items);
+    if (items.length < pageSize) {
+      break;
+    }
+    page += 1;
+  }
+  return all;
+}
+
 /**
  * @param {Object[]} rows
  * @param {string} controllerUrl
@@ -213,6 +264,35 @@ function setupResourceTypeImportCommand(rt) {
     });
 }
 
+function setupResourceTypeExportCommand(rt) {
+  rt
+    .command('export')
+    .description('Export resource types to baseline-shaped JSON')
+    .addHelpText('after', RESOURCE_TYPE_EXPORT_HELP_AFTER)
+    .requiredOption('--file <path>', 'Output path for baseline catalog JSON')
+    .action(async(options) => {
+      try {
+        const { controllerUrl, authConfig } = await resolveControllerAndAuth(options);
+        const records = await fetchAllResourceTypes(controllerUrl, authConfig);
+        const rows = records.map(mapResourceTypeApiToFileRow);
+        writeResourceTypeCatalogFile(options.file, rows);
+        if (rows.length === 0) {
+          logger.log(
+            infoLine(
+              'No resource types on the controller. Create or import types, then re-run export.'
+            )
+          );
+        }
+        logger.log(
+          formatSuccessLine(`Resource types exported: ${rows.length} written to ${options.file}`)
+        );
+      } catch (e) {
+        logger.error(formatBlockingError(e.message));
+        process.exit(1);
+      }
+    });
+}
+
 function setupResourceTypeCreateCommand(rt) {
   rt
     .command('create')
@@ -377,8 +457,8 @@ function setupResourceTypeListCommand(rt) {
           category: options.category,
           status: options.status
         });
-        const payload = unwrapControllerData(res);
-        const items = payload?.data ?? payload ?? [];
+        assertControllerListSuccess(res, 'resource types');
+        const items = extractControllerListItems(res);
         displayResourceTypeList(items, environment, headerControllerUrl);
       } catch (e) {
         logger.error(formatBlockingError(e.message));
@@ -397,6 +477,7 @@ function setupResourceTypeCommands(program) {
     .addHelpText('after', RESOURCE_TYPE_HELP_AFTER);
   setupResourceTypeCreateCommand(rt);
   setupResourceTypeImportCommand(rt);
+  setupResourceTypeExportCommand(rt);
   setupResourceTypeGetCommand(rt);
   setupResourceTypeListCommand(rt);
 }
@@ -406,5 +487,7 @@ module.exports = {
   requireResourceTypeKey,
   buildCreatePayload,
   unwrapControllerData,
-  importResourceTypeRows
+  importResourceTypeRows,
+  fetchAllResourceTypes,
+  mapResourceTypeApiToFileRow
 };