@aifabrix/builder 2.53.1 → 2.55.0

package/lib/integration-definition/apply-viewpoint-defaults.js

@@ -0,0 +1,157 @@
+/**
+ * Viewpoint grain and inherited date filter keys for BID apply.
+ *
+ * @fileoverview Prefer joined storage resourceType; copy date filterable fields
+ */
+
+'use strict';
+
+const { remapKey } = require('./apply-datasource-keys');
+
+/**
+ * @param {unknown} format
+ * @returns {boolean}
+ */
+function isDateFormat(format) {
+  const raw = String(format || '').toLowerCase();
+  return raw === 'date' || raw === 'date-time' || raw === 'datetime';
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @returns {string[]}
+ */
+function dateFilterableKeys(body) {
+  const props = body.metadataSchema && body.metadataSchema.properties;
+  if (!props || typeof props !== 'object') {
+    return [];
+  }
+  const exposed = body.exposed && Array.isArray(body.exposed.filterable)
+    ? body.exposed.filterable
+    : [];
+  const keys = [];
+  for (const [name, node] of Object.entries(props)) {
+    if (!node || typeof node !== 'object') {
+      continue;
+    }
+    if (!isDateFormat(node.format)) {
+      continue;
+    }
+    if (exposed.includes(name) || node.filter === true) {
+      keys.push(name);
+    }
+  }
+  return keys;
+}
+
+/**
+ * @param {Record<string, unknown>} viewBody
+ * @param {Record<string, unknown>} factBody
+ * @returns {void}
+ */
+function copyOneDateField(viewBody, factBody, key, props, filterable) {
+  const src = factBody.metadataSchema.properties[key];
+  if (!props[key]) {
+    props[key] = { ...src, filter: true };
+  } else if (typeof props[key] === 'object') {
+    props[key].filter = true;
+    if (!props[key].format && src && src.format) {
+      props[key].format = src.format;
+    }
+  }
+  if (!filterable.includes(key)) {
+    filterable.push(key);
+  }
+}
+
+function copyDateFilterableOntoView(viewBody, factBody) {
+  const keys = dateFilterableKeys(factBody);
+  if (keys.length === 0) {
+    return;
+  }
+  if (!viewBody.metadataSchema || typeof viewBody.metadataSchema !== 'object') {
+    viewBody.metadataSchema = { type: 'object', properties: {} };
+  }
+  const schema = /** @type {Record<string, unknown>} */ (viewBody.metadataSchema);
+  if (!schema.properties || typeof schema.properties !== 'object') {
+    schema.properties = {};
+  }
+  const props = /** @type {Record<string, unknown>} */ (schema.properties);
+  if (!viewBody.exposed || typeof viewBody.exposed !== 'object') {
+    viewBody.exposed = {};
+  }
+  const exposed = /** @type {Record<string, unknown>} */ (viewBody.exposed);
+  const filterable = Array.isArray(exposed.filterable) ? [...exposed.filterable] : [];
+  for (const key of keys) {
+    copyOneDateField(viewBody, factBody, key, props, filterable);
+  }
+  exposed.filterable = filterable;
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @returns {boolean}
+ */
+function isViewpointBody(body) {
+  const entityType = String(body.entityType || '');
+  const storageType = String(body.storageType || '');
+  return entityType === 'viewpoint' || storageType === 'view';
+}
+
+/**
+ * @param {Array<{ 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 {Array<{ body: Record<string, unknown> }>} dsFiles
+ * @param {unknown[]} relationships
+ * @param {Map<string, string>} keyMap
+ * @returns {void}
+ */
+function applyOneViewpoint(viewBody, rels, keyMap, bodies) {
+  const fromKey = String(viewBody.key || '');
+  const rel = rels.find((row) => row && remapKey(String(row.from || ''), keyMap) === fromKey);
+  if (!rel || typeof rel !== 'object') {
+    return;
+  }
+  const factKey = remapKey(String(rel.to || ''), keyMap);
+  const factBody = bodies.get(factKey);
+  if (!factBody) {
+    return;
+  }
+  const factType = String(factBody.resourceType || '').trim();
+  const viewType = String(viewBody.resourceType || '').trim();
+  if (factType && (!viewType || viewType === 'document')) {
+    viewBody.resourceType = factType;
+  }
+  copyDateFilterableOntoView(viewBody, factBody);
+}
+
+function applyViewpointDefaults(dsFiles, relationships, keyMap) {
+  const bodies = bodiesByKey(dsFiles);
+  const rels = Array.isArray(relationships) ? relationships : [];
+  for (const file of dsFiles || []) {
+    const viewBody = file.body;
+    if (!viewBody || !isViewpointBody(viewBody)) {
+      continue;
+    }
+    applyOneViewpoint(viewBody, rels, keyMap, bodies);
+  }
+}
+
+module.exports = {
+  applyViewpointDefaults,
+  dateFilterableKeys,
+  copyDateFilterableOntoView
+};

package/lib/integration-definition/apply.js

@@ -9,6 +9,15 @@ const path = require('path');
 const fsReal = require('../internal/fs-real-sync');
 const { getIntegrationPath } = require('../utils/paths');
 const { validateIntegrationDefinition } = require('./validate');
+const {
+  canonicalDatasourceKeyMap,
+  datasourceFileName
+} = require('./apply-datasource-keys');
+const { applyBidRelationships } = require('./apply-relationships');
+const { applyStaticAndEnterprise } = require('./apply-static-enterprise');
+const { applyViewpointDefaults } = require('./apply-viewpoint-defaults');
+const { stampCredentialTestEndpoint } = require('./apply-test-endpoint');
+const { buildSystemFile } = require('./apply-system-file');
 
 const STAMP_FILE = '.aifabrix-integration-definition.json';
 
@@ -96,6 +105,21 @@ function buildDatasourceSchema(labelField) {
   };
 }
 
+function mergeBidSchemaProperties(body, ds) {
+  const extra = ds.metadataSchema && ds.metadataSchema.properties;
+  if (!extra || typeof extra !== 'object') {
+    return;
+  }
+  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 = {};
+  }
+  Object.assign(schema.properties, extra);
+}
+
 function enrichDatasourceFile(body, ds, enrichOptions) {
   const { enrichDatasourceFromOpenApi } = require('./enrich-openapi-operations');
   const openapiSourceRef =
@@ -133,6 +157,8 @@ function buildDatasourceFile(ds, systemKey, capabilities, sync, enrichOptions =
     entityType: ds.entityType || 'recordStorage',
     resourceType: ds.resourceType,
     version: '1.0.0',
+    ...(ds.storageType ? { storageType: ds.storageType } : {}),
+    ...(ds.dimensions && typeof ds.dimensions === 'object' ? { dimensions: ds.dimensions } : {}),
     capabilities: buildDatasourceCapabilities(caps, key),
     // Schema sync is mode/schedule/batchSize only; BID sync.mode=incremental is operational intent.
     sync: { mode: 'pull', schedule: /** @type {any} */ (sync).schedule || '0 */6 * * *', batchSize: 100 },
@@ -143,6 +169,7 @@ function buildDatasourceFile(ds, systemKey, capabilities, sync, enrichOptions =
     // Mirror capabilities → openapi.operations + execution.cip.operations stubs (154.7).
   repairSyncOperationsFromCapabilities(body, []);
   seedPropertyKeysOnDatasource(body, ds.propertyKeys);
+  mergeBidSchemaProperties(body, ds);
   enrichDatasourceFile(body, ds, enrichOptions);
   return body;
 }
@@ -192,42 +219,6 @@ function collectAssociationObjectTypes(datasources, systemOpenapiSourceRef, enri
   return [...types];
 }
 
-/**
- * @param {Record<string, unknown>} bid
- * @returns {Record<string, unknown>}
- */
-function buildSystemFile(bid) {
-  const system = /** @type {Record<string, unknown>} */ (bid.system);
-  const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
-  const refs = /** @type {Record<string, string>} */ (system.connectionRefs || {});
-  const tokenRef = refs.token || refs.apiKey || Object.values(refs)[0] || `kv://${identity.systemKey}/token`;
-  return {
-    key: system.key,
-    displayName: system.displayName || identity.displayName,
-    description: system.description || identity.displayName,
-    type: system.type || 'openapi',
-    enabled: true,
-    systemKind: system.systemKind || 'crm',
-    authentication: {
-      authType: 'credential',
-      credential: {
-        credentialKey: `${identity.systemKey}-cred`,
-        method: 'bearerToken',
-        variables: {
-          baseUrl: refs.baseUrl || 'https://example.invalid',
-          headerName: 'Authorization',
-          prefix: 'Bearer'
-        },
-        security: {
-          token: tokenRef
-        },
-        writeOnce: true
-      }
-    },
-    dataSources: (/** @type {any[]} */ (bid.datasources) || []).map((d) => d.key)
-  };
-}
-
 /**
  * @param {Record<string, unknown>} bid
  * @param {string[]} datasourceFiles
@@ -290,45 +281,73 @@ function buildEnvTemplate(bid) {
  *   nextStamp: Record<string, unknown>
  * }}
  */
+function remappedCapabilities(capabilities, keyMap) {
+  const out = {};
+  for (const [key, value] of Object.entries(capabilities || {})) {
+    out[keyMap.get(key) || key] = value;
+  }
+  return out;
+}
+
+function buildApplyStamp(bid, systemKey, identity) {
+  return {
+    schemaName: bid.schemaName,
+    schemaVersion: bid.schemaVersion,
+    definitionId: bid.definitionId,
+    definitionHash: bid.definitionHash,
+    suiteRunId: /** @type {any} */ (bid.meta).suiteRunId,
+    systemKey,
+    packageVersion: identity.packageVersion,
+    appliedAt: new Date().toISOString()
+  };
+}
+
 function buildPackageArtifacts(bid, systemKey, enrichOptions = {}) {
   const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
   const datasources = /** @type {Record<string, unknown>[]} */ (bid.datasources || []);
-  const capabilities = /** @type {Record<string, string[]>} */ (bid.capabilities || {});
+  const capabilities = remappedCapabilities(
+    /** @type {Record<string, string[]>} */ (bid.capabilities || {}),
+    canonicalDatasourceKeyMap(datasources, systemKey)
+  );
   const sync = /** @type {Record<string, unknown>} */ (bid.sync || {});
-  const system = /** @type {Record<string, unknown>} */ (bid.system || {});
+  const systemBlock = /** @type {Record<string, unknown>} */ (bid.system || {});
   const systemOpenapiSourceRef =
-    typeof system.openapiSourceRef === 'string' ? system.openapiSourceRef : '';
+    typeof systemBlock.openapiSourceRef === 'string' ? systemBlock.openapiSourceRef : '';
   const associationTargets = collectAssociationObjectTypes(
     datasources,
     systemOpenapiSourceRef,
     enrichOptions
   );
+  const keyMap = canonicalDatasourceKeyMap(datasources, systemKey);
   const systemFile = `${systemKey}-system.json`;
-  const datasourceFiles = datasources.map((ds) => `${systemKey}-datasource-${ds.key}.json`);
-  return {
-    systemFile,
-    datasourceFiles,
-    application: buildApplicationFile(bid, datasourceFiles, systemFile),
-    system: buildSystemFile(bid),
-    dsFiles: datasources.map((ds) => ({
-      name: `${systemKey}-datasource-${ds.key}.json`,
-      body: buildDatasourceFile(ds, systemKey, capabilities, sync, {
+  const dsFiles = datasources.map((ds) => {
+    const canonicalKey = keyMap.get(String(ds.key)) || String(ds.key);
+    return {
+      name: datasourceFileName(systemKey, canonicalKey),
+      body: buildDatasourceFile({ ...ds, key: canonicalKey }, systemKey, capabilities, sync, {
         ...enrichOptions,
         systemOpenapiSourceRef,
         associationTargets
       })
-    })),
+    };
+  });
+  applyBidRelationships(dsFiles, /** @type {any[]} */ (bid.relationships) || [], keyMap);
+  applyStaticAndEnterprise(dsFiles, bid);
+  applyViewpointDefaults(dsFiles, /** @type {any[]} */ (bid.relationships) || [], keyMap);
+  const system = buildSystemFile(bid);
+  stampCredentialTestEndpoint(system, dsFiles);
+  return {
+    systemFile,
+    datasourceFiles: dsFiles.map((file) => file.name),
+    application: buildApplicationFile(
+      bid,
+      dsFiles.map((file) => file.name),
+      systemFile
+    ),
+    system,
+    dsFiles,
     envTemplate: buildEnvTemplate(bid),
-    nextStamp: {
-      schemaName: bid.schemaName,
-      schemaVersion: bid.schemaVersion,
-      definitionId: bid.definitionId,
-      definitionHash: bid.definitionHash,
-      suiteRunId: /** @type {any} */ (bid.meta).suiteRunId,
-      systemKey,
-      packageVersion: identity.packageVersion,
-      appliedAt: new Date().toISOString()
-    }
+    nextStamp: buildApplyStamp(bid, systemKey, identity)
   };
 }
 

package/lib/integration-definition/enrich-openapi-operations.js

@@ -10,6 +10,7 @@ const fsReal = require('../internal/fs-real-sync');
 const {
   maybeEnrichCrmStyleFieldMappings
 } = require('./enrich-crm-field-mappings');
+const { pickBestMatchingOp, entityTokensFromDatasource } = require('./enrich-openapi-pick');
 
 const PATH_PARAM_RE = /\{(\w+)\}/g;
 
@@ -171,7 +172,8 @@ function normalizeOp(method, opPath, op) {
     method: String(method || '').toUpperCase(),
     path: String(opPath),
     operationId: typeof op.operationId === 'string' ? op.operationId : '',
-    pathParamCount: params.length
+    pathParamCount: params.length,
+    tags: Array.isArray(op.tags) ? op.tags.map((row) => String(row || '')) : []
   };
 }
 
@@ -212,12 +214,29 @@ function isBatchOrSearch(text) {
  * @param {Array<{ method: string, path: string, operationId: string, pathParamCount: number }>} ops
  * @returns {{ method: string, path: string, operationId: string } | null}
  */
-function pickFirstMatchingOp(candidates, predicate, idPattern) {
-  const hits = candidates.filter(predicate);
-  return hits.find((op) => idPattern.test(op.operationId)) || hits[0] || null;
+function requiredQueryDefaults(doc, method, opPath) {
+  const out = {};
+  for (const param of operationParameters(doc, method, opPath)) {
+    if (!param || param.in !== 'query' || param.required !== true) {
+      continue;
+    }
+    const name = String(param.name || '').trim();
+    if (!name) {
+      continue;
+    }
+    const schema = param.schema && typeof param.schema === 'object' ? param.schema : {};
+    if (schema.default !== undefined) {
+      out[name] = schema.default;
+    } else if (typeof schema.minimum === 'number') {
+      out[name] = schema.minimum;
+    } else {
+      out[name] = `{{${name}}}`;
+    }
+  }
+  return out;
 }
 
-function pickOperationForCapability(capabilityKey, ops) {
+function pickOperationForCapability(capabilityKey, ops, entityTokens) {
   const key = String(capabilityKey || '').toLowerCase();
   const candidates = ops.filter((op) => !isBatchOrSearch(`${op.path} ${op.operationId}`));
   const rules = {
@@ -256,7 +275,7 @@ function pickOperationForCapability(capabilityKey, ops) {
   if (!rule) {
     return null;
   }
-  return pickFirstMatchingOp(candidates, rule.predicate, rule.idPattern);
+  return pickBestMatchingOp(candidates, rule.predicate, rule.idPattern, entityTokens);
 }
 
 /**
@@ -293,7 +312,11 @@ function bindOpenApiOperation(body, binding, capabilityKey) {
 
 function createCipQuery(capabilityKey, bindOptions) {
   const cap = String(capabilityKey || '').toLowerCase();
-  const query = {};
+  const query = {
+    ...(bindOptions.requiredQuery && typeof bindOptions.requiredQuery === 'object'
+      ? bindOptions.requiredQuery
+      : {})
+  };
   const targets = Array.isArray(bindOptions.associationTargets)
     ? bindOptions.associationTargets.map((row) => String(row || '').trim()).filter(Boolean)
     : [];
@@ -394,10 +417,11 @@ function enrichDatasourceFromOpenApi(body, openapiSourceRef, options = {}) {
   )
     .map((row) => String(row || '').trim())
     .filter((row) => row && row !== selfType);
+  const entityTokens = entityTokensFromDatasource(body);
   const bound = [];
   let samplePath = '';
   for (const capabilityKey of caps) {
-    const picked = pickOperationForCapability(capabilityKey, indexed);
+    const picked = pickOperationForCapability(capabilityKey, indexed, entityTokens);
     if (!picked) {
       continue;
     }
@@ -408,7 +432,8 @@ function enrichDatasourceFromOpenApi(body, openapiSourceRef, options = {}) {
         picked.path
       ),
       associationTargets,
-      cursorPagination: operationCursorPagination(doc, picked.method, picked.path)
+      cursorPagination: operationCursorPagination(doc, picked.method, picked.path),
+      requiredQuery: requiredQueryDefaults(doc, picked.method, picked.path)
     });
     bound.push(capabilityKey);
     if (!samplePath) {
@@ -429,5 +454,6 @@ module.exports = {
   enrichDatasourceFromOpenApi,
   objectTypeFromOpenApiPath,
   operationDeclaresAssociationsQuery,
-  operationCursorPagination
+  operationCursorPagination,
+  requiredQueryDefaults
 };

package/lib/integration-definition/enrich-openapi-pick.js

@@ -0,0 +1,87 @@
+/**
+ * Score OpenAPI operations by datasource entity tokens.
+ *
+ * @fileoverview Prefer path/tag overlap over first GET in a multi-entity spec
+ */
+
+'use strict';
+
+/**
+ * @param {Record<string, unknown>} body
+ * @returns {string[]}
+ */
+function entityTokensFromDatasource(body) {
+  const tokens = new Set();
+  for (const raw of [body.key, body.resourceType, body.displayName]) {
+    const value = String(raw || '').trim().toLowerCase();
+    if (!value) {
+      continue;
+    }
+    tokens.add(value);
+    for (const part of value.split(/[-_]/g)) {
+      if (part.length > 1) {
+        tokens.add(part);
+      }
+    }
+  }
+  return [...tokens];
+}
+
+/**
+ * @param {{ path?: string, operationId?: string, tags?: string[] }} op
+ * @param {string[]} tokens
+ * @returns {number}
+ */
+function scoreOpForEntity(op, tokens) {
+  if (!Array.isArray(tokens) || tokens.length === 0) {
+    return 0;
+  }
+  const path = String(op.path || '').toLowerCase();
+  const id = String(op.operationId || '').toLowerCase();
+  const tags = Array.isArray(op.tags)
+    ? op.tags.map((row) => String(row || '').toLowerCase()).join(' ')
+    : '';
+  const hay = `${path} ${id} ${tags}`;
+  const segments = path.split('/').filter(Boolean);
+  let score = 0;
+  for (const token of tokens) {
+    if (segments.includes(token)) {
+      score += 20;
+    } else if (hay.includes(token)) {
+      score += 10;
+    }
+  }
+  return score;
+}
+
+/**
+ * @param {Array<{ method: string, path: string, operationId: string }>} candidates
+ * @param {(op: object) => boolean} predicate
+ * @param {RegExp} idPattern
+ * @param {string[]} [entityTokens]
+ * @returns {object | null}
+ */
+function pickBestMatchingOp(candidates, predicate, idPattern, entityTokens) {
+  const hits = candidates.filter(predicate);
+  if (hits.length === 0) {
+    return null;
+  }
+  const tokens = Array.isArray(entityTokens) ? entityTokens : [];
+  if (tokens.length > 0) {
+    const scored = hits.map((op) => ({
+      op,
+      score: scoreOpForEntity(op, tokens) + (idPattern.test(op.operationId) ? 5 : 0)
+    }));
+    scored.sort((left, right) => right.score - left.score);
+    if (scored[0].score > 0) {
+      return scored[0].op;
+    }
+  }
+  return hits.find((op) => idPattern.test(op.operationId)) || hits[0] || null;
+}
+
+module.exports = {
+  entityTokensFromDatasource,
+  scoreOpForEntity,
+  pickBestMatchingOp
+};