@aifabrix/builder 2.49.2 → 2.51.0

package/lib/validation/external-manifest-validator.js

@@ -17,6 +17,7 @@ const { formatValidationErrors } = require('../utils/error-formatter');
 const { validateFieldReferences } = require('../datasource/field-reference-validator');
 const { validateAbac } = require('../datasource/abac-validator');
 const { validateManifestRuntimeConfiguration } = require('./runtime-configuration-rules');
+const { validateAppContractSurface } = require('./openapi-contract-surface-validator');
 
 /**
  * Load and normalize external-system + external-datasource schema objects for manifest AJV.
@@ -223,6 +224,7 @@ function validateDatasourceSystemKeyAlignment(manifest, errors) {
  * @async
  * @function validateControllerManifest
  * @param {Object} manifest - Controller manifest object
+ * @param {Object} [options] - Optional context (appPath for contract-surface checks)
  * @returns {Promise<Object>} Validation result
  * @throws {Error} If validation fails critically
  *
@@ -230,7 +232,7 @@ function validateDatasourceSystemKeyAlignment(manifest, errors) {
  * const result = await validateControllerManifest(manifest);
  * // Returns: { valid: true, errors: [], warnings: [] }
  */
-async function validateControllerManifest(manifest) {
+async function validateControllerManifest(manifest, options = {}) {
   if (!manifest || typeof manifest !== 'object') {
     return {
       valid: false,
@@ -249,6 +251,14 @@ async function validateControllerManifest(manifest) {
   validateDatasources(manifest, ajv, externalDatasourceSchema, errors, warnings);
   validateDatasourceSystemKeyAlignment(manifest, errors);
   errors.push(...validateManifestRuntimeConfiguration(manifest));
+  if (manifest.type === 'external' && Array.isArray(manifest.dataSources) && manifest.system?.key) {
+    const appPath = options.appPath;
+    if (typeof appPath === 'string' && appPath) {
+      const contract = validateAppContractSurface(appPath, manifest.system.key, manifest.dataSources);
+      errors.push(...contract.errors);
+      warnings.push(...contract.warnings);
+    }
+  }
   validateConditionalRequirements(manifest, errors, warnings);
   validateRequiredFields(manifest, errors);
 

package/lib/validation/openapi-contract-surface-validator.js

@@ -0,0 +1,430 @@
+/**
+ * Validate that OpenAPI / MCP contract surfaces are meaningful (not dataplane stubs).
+ *
+ * @fileoverview Contract surface validation for orchestration vs record datasources
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { buildOpenApiSpec } = require('../programmatic/openapi-spec');
+const {
+  documentKeyToLocalOpenApiPath,
+  isProgrammaticOrchestrationSystem,
+  specHasComponentSchemas
+} = require('../commands/repair-openapi-export');
+const {
+  validateVendorOperationContract,
+  findVendorOperation,
+  validateOrchestrationDatasourceContracts
+} = require('./openapi-contract-vendor-validation');
+
+const JSON_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head', 'options']);
+
+/**
+ * @param {Object} ds
+ * @returns {boolean}
+ */
+function isServiceContractDatasource(ds) {
+  const entity = String(ds?.entityType || '').trim().toLowerCase();
+  return entity === 'servicecontract';
+}
+
+/**
+ * @param {Object} ds
+ * @returns {boolean}
+ */
+function isCompositionNoneDatasource(ds) {
+  return String(ds?.entityType || '').trim().toLowerCase() === 'none';
+}
+
+/**
+ * @param {Object} ds
+ * @returns {boolean}
+ */
+function hasVendorOpenapiOnManifest(ds) {
+  const openapi = ds?.openapi;
+  if (!openapi || typeof openapi !== 'object' || openapi.enabled === false) {
+    return false;
+  }
+  const operations = openapi.operations;
+  if (operations && typeof operations === 'object' && Object.keys(operations).length > 0) {
+    return true;
+  }
+  const documentKey =
+    typeof openapi.documentKey === 'string' ? openapi.documentKey.trim() : '';
+  return Boolean(documentKey) || openapi.enabled === true;
+}
+
+/**
+ * @deprecated use isServiceContractDatasource — kept for tests importing legacy name
+ * @param {Object} ds
+ * @returns {boolean}
+ */
+function isOrchestrationDatasource(ds) {
+  return isServiceContractDatasource(ds);
+}
+
+/**
+ * @param {Object|undefined} op
+ * @returns {boolean}
+ */
+function operationHasRequestOrResponseSchema(op) {
+  if (!op || typeof op !== 'object') {
+    return false;
+  }
+  if (op.requestBody) {
+    return true;
+  }
+  const responses = op.responses;
+  if (!responses || typeof responses !== 'object') {
+    return false;
+  }
+  for (const response of Object.values(responses)) {
+    if (response && typeof response === 'object' && response.content) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {Object|undefined} paths
+ * @returns {boolean}
+ */
+function pathsHaveRequestOrResponseSchemas(paths) {
+  if (!paths || typeof paths !== 'object') {
+    return false;
+  }
+  for (const pathItem of Object.values(paths)) {
+    if (!pathItem || typeof pathItem !== 'object') {
+      continue;
+    }
+    for (const [method, op] of Object.entries(pathItem)) {
+      if (!JSON_METHODS.has(method)) {
+        continue;
+      }
+      if (operationHasRequestOrResponseSchema(op)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {unknown} spec
+ * @returns {boolean}
+ */
+function isThinOpenApiSpec(spec) {
+  if (!spec || typeof spec !== 'object') {
+    return true;
+  }
+  if (specHasComponentSchemas(spec)) {
+    return false;
+  }
+  return !pathsHaveRequestOrResponseSchemas(spec.paths);
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Object|null}
+ */
+function readJsonIfExists(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {string} documentKey
+ * @returns {{ spec: Object|null, localPath: string, fromMemory: boolean }}
+ */
+function resolveVendorOpenApiSpec(appPath, systemKey, documentKey) {
+  const localPath = documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey);
+  const fromDisk = readJsonIfExists(localPath);
+  if (fromDisk) {
+    return { spec: fromDisk, localPath, fromMemory: false };
+  }
+  if (isProgrammaticOrchestrationSystem(systemKey)) {
+    const spec = buildOpenApiSpec();
+    return { spec, localPath, fromMemory: true };
+  }
+  return { spec: null, localPath, fromMemory: false };
+}
+
+/**
+ * @param {Object} ds
+ * @param {string} prefix
+ * @returns {string[]}
+ */
+function collectServiceContractFieldMappingErrors(ds, prefix) {
+  const fieldMappings = ds.fieldMappings;
+  const attributes =
+    fieldMappings && typeof fieldMappings === 'object' ? fieldMappings.attributes : null;
+  const hasAttributes =
+    attributes && typeof attributes === 'object' && Object.keys(attributes).length > 0;
+  if (hasAttributes) {
+    return [];
+  }
+  return [
+    `${prefix}serviceContract requires fieldMappings.attributes — public contract must be testable`
+  ];
+}
+
+/**
+ * @param {Object} ds
+ * @param {string} prefix
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function collectServiceContractExposedIssues(ds, prefix) {
+  const errors = [];
+  const warnings = [];
+  const exposed = ds.exposed;
+  const schema = exposed && typeof exposed === 'object' ? exposed.schema : null;
+  if (!schema || typeof schema !== 'object' || Object.keys(schema).length === 0) {
+    errors.push(`${prefix}serviceContract requires exposed.schema for MCP/REST contract`);
+  }
+  const profiles = exposed && typeof exposed === 'object' ? exposed.profiles : null;
+  if (!profiles || typeof profiles !== 'object' || Object.keys(profiles).length === 0) {
+    warnings.push(`${prefix}serviceContract missing exposed.profiles — add default envelope`);
+  }
+  return { errors, warnings };
+}
+
+/**
+ * @param {Object} ds
+ * @param {string} prefix
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateServiceContractDatasourceContracts(ds, prefix) {
+  const errors = collectServiceContractFieldMappingErrors(ds, prefix);
+  const exposed = collectServiceContractExposedIssues(ds, prefix);
+  errors.push(...exposed.errors);
+  return { errors, warnings: exposed.warnings };
+}
+
+/**
+ * @param {Object} ds
+ * @param {string} prefix
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateRecordDatasourceContracts(ds, prefix) {
+  const errors = [];
+  const warnings = [];
+  const caps = ds.capabilities;
+  const capList = Array.isArray(caps) ? caps.map((c) => String(c).toLowerCase()) : [];
+  const needsExposed = capList.some((c) => ['create', 'update', 'list', 'get'].includes(c));
+  const fieldMappings = ds.fieldMappings;
+  const attributes =
+    fieldMappings && typeof fieldMappings === 'object' ? fieldMappings.attributes : null;
+  const hasAttributes =
+    attributes && typeof attributes === 'object' && Object.keys(attributes).length > 0;
+  if (!hasAttributes) {
+    errors.push(
+      `${prefix}fieldMappings.attributes is missing or empty — record entities need mapped fields for sync and MCP schemas`
+    );
+  }
+  const exposed = ds.exposed;
+  const profiles = exposed && typeof exposed === 'object' ? exposed.profiles : null;
+  const hasProfiles =
+    profiles && typeof profiles === 'object' && Object.keys(profiles).length > 0;
+  if (needsExposed && !hasProfiles) {
+    errors.push(
+      `${prefix}exposed.profiles is missing or empty — record entities need exposed schema profiles for MCP/OpenAPI`
+    );
+  }
+  return { errors, warnings };
+}
+
+/**
+ * @param {Object} ds
+ * @param {string} prefix
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateNoneDatasourceContract(ds, prefix) {
+  const errors = [];
+  const warnings = [];
+  if (hasVendorOpenapiOnManifest(ds)) {
+    warnings.push(
+      `${prefix}entityType none must not bind vendor OpenAPI — run repair to migrate to serviceContract`
+    );
+  }
+  return { errors, warnings };
+}
+
+/**
+ * @param {string} documentKey
+ * @param {string} prefix
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {Map<string, Object|null>} vendorCache
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function resolveCachedVendorSpec(documentKey, prefix, appPath, systemKey, vendorCache) {
+  const errors = [];
+  const warnings = [];
+  const resolved = resolveVendorOpenApiSpec(appPath, systemKey, documentKey);
+  vendorCache.set(documentKey, resolved.spec);
+  if (!resolved.spec) {
+    errors.push(
+      `${prefix}missing vendor OpenAPI at ${resolved.localPath} — run: aifabrix repair ${systemKey} --api`
+    );
+    return { errors, warnings, spec: null };
+  }
+  if (isThinOpenApiSpec(resolved.spec)) {
+    errors.push(
+      `${prefix}vendor OpenAPI "${documentKey}" is a thin stub (no component schemas / body schemas) — run: aifabrix repair ${systemKey} --api`
+    );
+    return { errors, warnings, spec: null };
+  }
+  if (resolved.fromMemory) {
+    warnings.push(
+      `${prefix}vendor OpenAPI "${documentKey}" not on disk; validated from in-memory programmatic spec — run: aifabrix repair ${systemKey} --api to materialize openapi/`
+    );
+  }
+  return { errors, warnings, spec: resolved.spec };
+}
+
+/**
+ * @param {Object} ds
+ * @param {string} prefix
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {Map<string, Object|null>} vendorCache
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateServiceContractVendorOpenApi(ds, prefix, appPath, systemKey, vendorCache) {
+  const errors = [];
+  const warnings = [];
+  // Python/CIP handlers without a vendor OpenAPI binding are valid serviceContracts.
+  if (!hasVendorOpenapiOnManifest(ds)) {
+    return { errors, warnings };
+  }
+  const documentKey =
+    typeof ds.openapi?.documentKey === 'string' ? ds.openapi.documentKey.trim() : '';
+  if (!documentKey) {
+    errors.push(`${prefix}serviceContract with OpenAPI upstream requires openapi.documentKey`);
+    return { errors, warnings };
+  }
+  if (!vendorCache.has(documentKey)) {
+    const cached = resolveCachedVendorSpec(documentKey, prefix, appPath, systemKey, vendorCache);
+    errors.push(...cached.errors);
+    warnings.push(...cached.warnings);
+    if (!cached.spec) {
+      return { errors, warnings };
+    }
+  }
+  const vendorSpec = vendorCache.get(documentKey);
+  const orch = validateOrchestrationDatasourceContracts(ds, vendorSpec, prefix);
+  errors.push(...orch.errors);
+  warnings.push(...orch.warnings);
+  return { errors, warnings };
+}
+
+/**
+ * @param {Object} ds
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {Map<string, Object|null>} vendorCache
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateDatasourceContractSurface(ds, appPath, systemKey, vendorCache) {
+  const prefix = `Datasource "${ds.key || '(unknown)'}": `;
+  if (isCompositionNoneDatasource(ds)) {
+    return validateNoneDatasourceContract(ds, prefix);
+  }
+  if (isServiceContractDatasource(ds)) {
+    const sc = validateServiceContractDatasourceContracts(ds, prefix);
+    const vendor = validateServiceContractVendorOpenApi(
+      ds,
+      prefix,
+      appPath,
+      systemKey,
+      vendorCache
+    );
+    return {
+      errors: [...sc.errors, ...vendor.errors],
+      warnings: [...sc.warnings, ...vendor.warnings]
+    };
+  }
+  return validateRecordDatasourceContracts(ds, prefix);
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {Object[]} datasources
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateAppContractSurface(appPath, systemKey, datasources) {
+  const errors = [];
+  const warnings = [];
+  const vendorCache = new Map();
+  for (const ds of datasources || []) {
+    if (!ds || typeof ds !== 'object') {
+      continue;
+    }
+    const result = validateDatasourceContractSurface(ds, appPath, systemKey, vendorCache);
+    errors.push(...result.errors);
+    warnings.push(...result.warnings);
+  }
+  return { errors, warnings };
+}
+
+/**
+ * @param {string} filePath
+ * @returns {{ appPath: string, systemKey: string }|null}
+ */
+function inferIntegrationContextFromPath(filePath) {
+  const normalized = path.normalize(filePath);
+  const parts = normalized.split(path.sep);
+  const integrationIdx = parts.lastIndexOf('integration');
+  if (integrationIdx < 0 || integrationIdx + 1 >= parts.length) {
+    return null;
+  }
+  const systemKey = parts[integrationIdx + 1];
+  const appPath = parts.slice(0, integrationIdx + 2).join(path.sep);
+  return { appPath, systemKey };
+}
+
+/**
+ * @param {Object} parsedDatasource
+ * @param {string} filePath
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateDatasourceFileContractSurface(parsedDatasource, filePath) {
+  const ctx = inferIntegrationContextFromPath(filePath);
+  if (!ctx) {
+    return { errors: [], warnings: [] };
+  }
+  return validateDatasourceContractSurface(
+    parsedDatasource,
+    ctx.appPath,
+    ctx.systemKey,
+    new Map()
+  );
+}
+
+module.exports = {
+  isOrchestrationDatasource,
+  isServiceContractDatasource,
+  isCompositionNoneDatasource,
+  hasVendorOpenapiOnManifest,
+  isThinOpenApiSpec,
+  validateAppContractSurface,
+  validateDatasourceFileContractSurface,
+  validateVendorOperationContract,
+  validateServiceContractDatasourceContracts,
+  findVendorOperation
+};

package/lib/validation/openapi-contract-vendor-validation.js

@@ -0,0 +1,238 @@
+/**
+ * Vendor OpenAPI operation contract checks for serviceContract datasources.
+ *
+ * @fileoverview Extracted from openapi-contract-surface-validator (max-lines split)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const MUTATING_METHODS = new Set(['post', 'put', 'patch']);
+
+/**
+ * @param {Object|undefined} content
+ * @returns {boolean}
+ */
+function hasJsonSchemaContent(content) {
+  if (!content || typeof content !== 'object') {
+    return false;
+  }
+  const json = content['application/json'];
+  if (!json || typeof json !== 'object') {
+    return false;
+  }
+  const schema = json.schema;
+  return Boolean(schema && typeof schema === 'object' && Object.keys(schema).length > 0);
+}
+
+/**
+ * @param {Object|undefined} op
+ * @returns {boolean}
+ */
+function operationHasParameters(op) {
+  const params = op?.parameters;
+  return Array.isArray(params) && params.length > 0;
+}
+
+/**
+ * @param {Object|undefined} opCfg
+ * @returns {{ requestBody: boolean, responseBody: boolean }}
+ */
+function readContractExempt(opCfg) {
+  const raw = opCfg?.contractExempt || opCfg?.contractSurfaceExempt;
+  if (!raw || typeof raw !== 'object') {
+    return { requestBody: false, responseBody: false };
+  }
+  return {
+    requestBody: raw.requestBody === true,
+    responseBody: raw.responseBody === true
+  };
+}
+
+/**
+ * @param {Object|undefined} vendorOp
+ * @param {Object|undefined} opCfg
+ * @param {string} opKey
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateVendorOperationContract(vendorOp, opCfg, opKey) {
+  const errors = [];
+  const warnings = [];
+  const exempt = readContractExempt(opCfg);
+  const method = String(opCfg?.method || 'get').trim().toLowerCase();
+  if (!vendorOp || typeof vendorOp !== 'object') {
+    errors.push(
+      `openapi.operations.${opKey}: no matching operation in vendor OpenAPI (check path, method, operationId)`
+    );
+    return { errors, warnings };
+  }
+  validateRequestSurface(vendorOp, method, opKey, exempt, errors, warnings);
+  validateResponseSurface(vendorOp, method, opKey, exempt, errors, warnings);
+  return { errors, warnings };
+}
+
+/**
+ * @param {Object} vendorOp
+ * @param {string} method
+ * @param {string} opKey
+ * @param {{ requestBody: boolean, responseBody: boolean }} exempt
+ * @param {string[]} errors
+ * @param {string[]} warnings
+ */
+function validateRequestSurface(vendorOp, method, opKey, exempt, errors, warnings) {
+  if (!MUTATING_METHODS.has(method) || exempt.requestBody) {
+    return;
+  }
+  const hasBody = hasJsonSchemaContent(vendorOp.requestBody?.content);
+  const hasParams = operationHasParameters(vendorOp);
+  if (hasBody || hasParams) {
+    if (!hasBody && hasParams) {
+      warnings.push(
+        `openapi.operations.${opKey}: POST/PUT/PATCH uses query/path parameters only (no requestBody schema) — allowed for edge cases like eventStart?id=`
+      );
+    }
+    return;
+  }
+  errors.push(
+    `openapi.operations.${opKey}: mutating operation has no requestBody schema and no parameters — agents cannot send inputs`
+  );
+}
+
+/**
+ * @param {Object} vendorOp
+ * @param {string} method
+ * @param {string} opKey
+ * @param {{ requestBody: boolean, responseBody: boolean }} exempt
+ * @param {string[]} errors
+ * @param {string[]} warnings
+ */
+function validateResponseSurface(vendorOp, method, opKey, exempt, errors, warnings) {
+  if (exempt.responseBody) {
+    return;
+  }
+  const responses = vendorOp.responses;
+  if (!responses || typeof responses !== 'object') {
+    pushResponseIssue(method, opKey, errors, warnings);
+    return;
+  }
+  if (responses['204']) {
+    return;
+  }
+  for (const status of ['200', '201', '202']) {
+    const response = responses[status];
+    if (response && hasJsonSchemaContent(response.content)) {
+      return;
+    }
+  }
+  pushResponseIssue(method, opKey, errors, warnings);
+}
+
+/**
+ * @param {string} method
+ * @param {string} opKey
+ * @param {string[]} errors
+ * @param {string[]} warnings
+ */
+function pushResponseIssue(method, opKey, errors, warnings) {
+  const msg =
+    `openapi.operations.${opKey}: no JSON response schema on 200/201/202 — ` +
+    'MCP outputSchema and live validation will be empty';
+  if (MUTATING_METHODS.has(method)) {
+    errors.push(msg);
+    return;
+  }
+  warnings.push(msg);
+}
+
+/**
+ * @param {Object|undefined} paths
+ * @param {string} pathKey
+ * @param {string} method
+ * @returns {Object|null}
+ */
+function findVendorOperationByPath(paths, pathKey, method) {
+  if (!pathKey || !paths || typeof paths !== 'object') {
+    return null;
+  }
+  const pathItem = paths[pathKey];
+  if (!pathItem || typeof pathItem !== 'object') {
+    return null;
+  }
+  return pathItem[method] || null;
+}
+
+/**
+ * @param {Object|undefined} paths
+ * @param {string} operationId
+ * @returns {Object|null}
+ */
+function findVendorOperationById(paths, operationId) {
+  if (!operationId || !paths || typeof paths !== 'object') {
+    return null;
+  }
+  for (const pathItem of Object.values(paths)) {
+    if (!pathItem || typeof pathItem !== 'object') {
+      continue;
+    }
+    for (const op of Object.values(pathItem)) {
+      if (op && typeof op === 'object' && String(op.operationId || '').trim() === operationId) {
+        return op;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {Object|undefined} vendorSpec
+ * @param {Object|undefined} opCfg
+ * @returns {Object|null}
+ */
+function findVendorOperation(vendorSpec, opCfg) {
+  if (!vendorSpec || typeof vendorSpec !== 'object' || !opCfg || typeof opCfg !== 'object') {
+    return null;
+  }
+  const paths = vendorSpec.paths;
+  const pathKey = typeof opCfg.path === 'string' ? opCfg.path.trim() : '';
+  const method = String(opCfg.method || 'get').trim().toLowerCase();
+  const byPath = findVendorOperationByPath(paths, pathKey, method);
+  if (byPath) {
+    return byPath;
+  }
+  const operationId = typeof opCfg.operationId === 'string' ? opCfg.operationId.trim() : '';
+  return findVendorOperationById(paths, operationId);
+}
+
+/**
+ * @param {Object} ds
+ * @param {Object|null} vendorSpec
+ * @param {string} prefix
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateOrchestrationDatasourceContracts(ds, vendorSpec, prefix) {
+  const errors = [];
+  const warnings = [];
+  const openapi = ds.openapi;
+  if (!openapi || openapi.enabled !== true) {
+    return { errors, warnings };
+  }
+  const operations = openapi.operations;
+  if (!operations || typeof operations !== 'object') {
+    errors.push(`${prefix}openapi.enabled but openapi.operations is missing`);
+    return { errors, warnings };
+  }
+  for (const [opKey, opCfg] of Object.entries(operations)) {
+    const vendorOp = findVendorOperation(vendorSpec, opCfg);
+    const result = validateVendorOperationContract(vendorOp, opCfg, opKey);
+    result.errors.forEach((e) => errors.push(`${prefix}${e}`));
+    result.warnings.forEach((w) => warnings.push(`${prefix}${w}`));
+  }
+  return { errors, warnings };
+}
+
+module.exports = {
+  validateVendorOperationContract,
+  findVendorOperation,
+  validateOrchestrationDatasourceContracts
+};