@aifabrix/builder 2.53.1 → 2.55.0

package/lib/integration-definition/apply-datasource-keys.js

@@ -0,0 +1,75 @@
+/**
+ * Canonical tenant-global datasource keys for BID apply.
+ *
+ * @fileoverview Prefix single-token keys; keep unique kebab keys
+ */
+
+'use strict';
+
+const { isScopedKebabKey } = require('../commands/repair-datasource-key-skip');
+
+/**
+ * @param {string} dsKey
+ * @param {string} systemKey
+ * @returns {string}
+ */
+function canonicalDatasourceKey(dsKey, systemKey) {
+  const key = String(dsKey || '').trim();
+  const sys = String(systemKey || '').trim();
+  if (!key) {
+    return key;
+  }
+  if (sys && key.startsWith(`${sys}-`)) {
+    return key;
+  }
+  if (isScopedKebabKey(key)) {
+    return key;
+  }
+  return sys ? `${sys}-${key}` : key;
+}
+
+/**
+ * @param {Array<{ key?: string }>} datasources
+ * @param {string} systemKey
+ * @returns {Map<string, string>}
+ */
+function canonicalDatasourceKeyMap(datasources, systemKey) {
+  const map = new Map();
+  for (const ds of datasources || []) {
+    const from = String(ds.key || '').trim();
+    if (!from) {
+      continue;
+    }
+    map.set(from, canonicalDatasourceKey(from, systemKey));
+  }
+  return map;
+}
+
+/**
+ * @param {string} systemKey
+ * @param {string} canonicalKey
+ * @returns {string}
+ */
+function datasourceFileName(systemKey, canonicalKey) {
+  const sys = String(systemKey || '');
+  const key = String(canonicalKey || '');
+  const suffix = sys && key.startsWith(`${sys}-`) ? key.slice(sys.length + 1) : key;
+  return `${sys}-datasource-${suffix}.json`;
+}
+
+/**
+ * @param {string} key
+ * @param {Map<string, string>} keyMap
+ * @returns {string}
+ */
+function remapKey(key, keyMap) {
+  const raw = String(key || '').trim();
+  return (keyMap && keyMap.get(raw)) || raw;
+}
+
+module.exports = {
+  canonicalDatasourceKey,
+  canonicalDatasourceKeyMap,
+  datasourceFileName,
+  remapKey
+};

package/lib/integration-definition/apply-relationships.js

@@ -0,0 +1,195 @@
+/**
+ * Compile BID relationships[] into EDS foreignKeys and child type:fk dimensions.
+ *
+ * @fileoverview BID relationship compile for apply
+ */
+
+'use strict';
+
+const { remapKey } = require('./apply-datasource-keys');
+
+/**
+ * @param {Record<string, unknown>} rel
+ * @returns {string[]}
+ */
+function carrierFieldsFromRelationship(rel) {
+  if (Array.isArray(rel.fields) && rel.fields.length > 0) {
+    return rel.fields.map((row) => String(row || '').trim()).filter(Boolean);
+  }
+  if (typeof rel.field === 'string' && rel.field.trim()) {
+    return [rel.field.trim()];
+  }
+  if (typeof rel.carrier === 'string' && rel.carrier.trim()) {
+    return [rel.carrier.trim()];
+  }
+  return [];
+}
+
+/**
+ * @param {string[]} fields
+ * @returns {string}
+ */
+function fkNameFromCarrier(fields) {
+  const raw = String((fields && fields[0]) || '').trim();
+  if (/^[a-z][a-zA-Z0-9]*$/.test(raw)) {
+    return raw;
+  }
+  const camel = raw.replace(/[-_]([a-zA-Z0-9])/g, (_, ch) => String(ch).toUpperCase());
+  return /^[a-z][a-zA-Z0-9]*$/.test(camel) ? camel : '';
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @param {string} carrier
+ * @returns {void}
+ */
+function carrierPropertyNode(props, carrier) {
+  const existing = props[carrier] && typeof props[carrier] === 'object'
+    ? /** @type {Record<string, unknown>} */ (props[carrier])
+    : { type: 'string' };
+  return { ...existing, type: existing.type || 'string', index: true, filter: true };
+}
+
+function ensureCarrierMappings(body, carrier) {
+  if (!body.fieldMappings || typeof body.fieldMappings !== 'object') {
+    body.fieldMappings = { attributes: {} };
+  }
+  const mappings = /** @type {Record<string, unknown>} */ (body.fieldMappings);
+  if (!mappings.attributes || typeof mappings.attributes !== 'object') {
+    mappings.attributes = {};
+  }
+  const attrs = /** @type {Record<string, unknown>} */ (mappings.attributes);
+  if (!attrs[carrier]) {
+    attrs[carrier] = { expression: `{{raw.${carrier}}}`, description: 'Join carrier' };
+  }
+}
+
+function ensureCarrierExposed(body, carrier) {
+  if (!body.exposed || typeof body.exposed !== 'object') {
+    body.exposed = {};
+  }
+  const exposed = /** @type {Record<string, unknown>} */ (body.exposed);
+  const filterable = Array.isArray(exposed.filterable) ? [...exposed.filterable] : [];
+  if (!filterable.includes(carrier)) {
+    filterable.push(carrier);
+  }
+  exposed.filterable = filterable;
+}
+
+function ensureCarrierOnChild(body, carrier) {
+  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 = {};
+  }
+  const props = /** @type {Record<string, unknown>} */ (schema.properties);
+  props[carrier] = carrierPropertyNode(props, carrier);
+  ensureCarrierMappings(body, carrier);
+  ensureCarrierExposed(body, carrier);
+}
+
+/**
+ * @param {Record<string, unknown>} childBody
+ * @param {Record<string, unknown>} parentBody
+ * @param {string} fkName
+ * @returns {void}
+ */
+function copyParentCatalogDimsAsFk(childBody, parentBody, fkName) {
+  const parentDims = parentBody.dimensions;
+  if (!parentDims || typeof parentDims !== 'object' || Array.isArray(parentDims)) {
+    return;
+  }
+  if (!childBody.dimensions || typeof childBody.dimensions !== 'object') {
+    childBody.dimensions = {};
+  }
+  const childDims = /** @type {Record<string, unknown>} */ (childBody.dimensions);
+  for (const [dimKey, binding] of Object.entries(parentDims)) {
+    if (!binding || typeof binding !== 'object' || childDims[dimKey]) {
+      continue;
+    }
+    childDims[dimKey] = { type: 'fk', via: [{ fk: fkName, dimension: dimKey }] };
+  }
+}
+
+/**
+ * @param {Array<{ name: string, 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 {Record<string, unknown>} childBody
+ * @param {string} name
+ * @param {string[]} fields
+ * @param {string} targetKey
+ * @returns {void}
+ */
+function upsertForeignKey(childBody, name, fields, targetKey) {
+  if (!Array.isArray(childBody.foreignKeys)) {
+    childBody.foreignKeys = [];
+  }
+  const rows = /** @type {Array<Record<string, unknown>>} */ (childBody.foreignKeys);
+  const next = {
+    name,
+    fields,
+    targetDatasource: targetKey,
+    targetFields: ['externalId']
+  };
+  const idx = rows.findIndex((row) => row && row.name === name);
+  if (idx >= 0) {
+    rows[idx] = { ...rows[idx], ...next };
+    return;
+  }
+  rows.push(next);
+}
+
+/**
+ * @param {Array<{ name: string, body: Record<string, unknown> }>} dsFiles
+ * @param {unknown[]} relationships
+ * @param {Map<string, string>} keyMap
+ * @returns {void}
+ */
+function applyBidRelationships(dsFiles, relationships, keyMap) {
+  if (!Array.isArray(relationships) || relationships.length === 0) {
+    return;
+  }
+  const bodies = bodiesByKey(dsFiles);
+  for (const rel of relationships) {
+    if (!rel || typeof rel !== 'object') {
+      continue;
+    }
+    const row = /** @type {Record<string, unknown>} */ (rel);
+    const fields = carrierFieldsFromRelationship(row);
+    const fkName = fkNameFromCarrier(fields);
+    if (!fkName) {
+      continue;
+    }
+    const fromKey = remapKey(String(row.from || ''), keyMap);
+    const toKey = remapKey(String(row.to || ''), keyMap);
+    const childBody = bodies.get(fromKey);
+    const parentBody = bodies.get(toKey);
+    if (!childBody || !parentBody) {
+      continue;
+    }
+    ensureCarrierOnChild(childBody, fkName);
+    upsertForeignKey(childBody, fkName, [fkName], toKey);
+    copyParentCatalogDimsAsFk(childBody, parentBody, fkName);
+  }
+}
+
+module.exports = {
+  applyBidRelationships,
+  carrierFieldsFromRelationship,
+  fkNameFromCarrier
+};

package/lib/integration-definition/apply-static-enterprise.js

@@ -0,0 +1,229 @@
+/**
+ * Static file-load CIP + published enterprise REST paths for BID apply.
+ *
+ * @fileoverview authType none uses record fetch; stamp enterprise path
+ */
+
+'use strict';
+
+const PLACEHOLDER_HOST = /example\.invalid|api\.example\.com/i;
+
+/**
+ * @param {Record<string, unknown>} bid
+ * @returns {boolean}
+ */
+function isStaticFileLoadBid(bid) {
+  const system = bid && bid.system && typeof bid.system === 'object'
+    ? /** @type {Record<string, unknown>} */ (bid.system)
+    : {};
+  const auth = system.authentication && typeof system.authentication === 'object'
+    ? /** @type {Record<string, unknown>} */ (system.authentication)
+    : null;
+  if (auth && auth.authType === 'none') {
+    return true;
+  }
+  if (String(system.type || '') === 'custom' && !hasVendorBaseUrl(system)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @param {Record<string, unknown>} system
+ * @returns {boolean}
+ */
+function hasVendorBaseUrl(system) {
+  const refs = system.connectionRefs && typeof system.connectionRefs === 'object'
+    ? /** @type {Record<string, string>} */ (system.connectionRefs)
+    : {};
+  const url = String(refs.baseUrl || '').trim();
+  if (!url || PLACEHOLDER_HOST.test(url)) {
+    return false;
+  }
+  return /^https?:\/\//i.test(url);
+}
+
+/**
+ * @param {Record<string, unknown>} op
+ * @returns {void}
+ */
+function setRecordFetch(op) {
+  const steps = Array.isArray(op.steps) ? op.steps : [];
+  let found = false;
+  for (const step of steps) {
+    if (step && step.fetch && typeof step.fetch === 'object') {
+      step.fetch.source = 'record';
+      found = true;
+    }
+  }
+  if (!found) {
+    steps.unshift({ fetch: { source: 'record', query: {} } });
+    if (!steps.some((row) => row && row.output)) {
+      steps.push({ output: { mode: 'records' } });
+    }
+    op.steps = steps;
+  }
+  op.enabled = true;
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @param {string} capKey
+ * @returns {void}
+ */
+function ensureRecordCapability(body, capKey) {
+  if (!body.execution || typeof body.execution !== 'object') {
+    body.execution = { engine: 'cip' };
+  }
+  const execution = /** @type {Record<string, unknown>} */ (body.execution);
+  if (!execution.cip || typeof execution.cip !== 'object') {
+    execution.cip = { version: '1.0', operations: {} };
+  }
+  const cip = /** @type {Record<string, unknown>} */ (execution.cip);
+  if (!cip.operations || typeof cip.operations !== 'object') {
+    cip.operations = {};
+  }
+  const ops = /** @type {Record<string, unknown>} */ (cip.operations);
+  if (!ops[capKey] || typeof ops[capKey] !== 'object') {
+    ops[capKey] = { enabled: true, description: `Local ${capKey}`, steps: [] };
+  }
+  setRecordFetch(/** @type {Record<string, unknown>} */ (ops[capKey]));
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @param {string} capKey
+ * @param {boolean} overwritePath
+ * @returns {void}
+ */
+function stampEnterpriseOp(body, capKey, overwritePath) {
+  const resourceType = String(body.resourceType || '').trim();
+  if (!resourceType) {
+    return;
+  }
+  if (!body.openapi || typeof body.openapi !== 'object') {
+    body.openapi = { enabled: true, operations: {} };
+  }
+  const openapi = /** @type {Record<string, unknown>} */ (body.openapi);
+  openapi.enabled = true;
+  if (!openapi.operations || typeof openapi.operations !== 'object') {
+    openapi.operations = {};
+  }
+  const ops = /** @type {Record<string, unknown>} */ (openapi.operations);
+  const prev = ops[capKey] && typeof ops[capKey] === 'object'
+    ? /** @type {Record<string, unknown>} */ (ops[capKey])
+    : {};
+  const next = { ...prev, operationId: prev.operationId || capKey };
+  if (!next.restRuntime) {
+    next.restRuntime = { pathKind: 'collectionSubresource' };
+  }
+  if (overwritePath || !next.path) {
+    next.path = `/enterprise/${resourceType}/${capKey}`;
+    next.method = next.method || 'POST';
+  }
+  ops[capKey] = next;
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @param {string} capKey
+ * @returns {void}
+ */
+function ensureCapabilityObject(body, capKey) {
+  if (!Array.isArray(body.capabilities)) {
+    body.capabilities = [];
+  }
+  const keys = capabilityKeysOf(body);
+  if (keys.includes(capKey) || keys.includes(`${capKey}Basic`)) {
+    return;
+  }
+  body.capabilities.push({
+    key: capKey,
+    description: `Local ${capKey}`,
+    riskLevel: 'medium',
+    approvalRequired: false
+  });
+}
+
+function capabilityKeysOf(body) {
+  if (!Array.isArray(body.capabilities)) {
+    return ['list', 'get'];
+  }
+  return body.capabilities
+    .map((row) => (row && typeof row === 'object' ? row.key : row))
+    .filter((key) => typeof key === 'string' && key.trim())
+    .map((key) => String(key).trim());
+}
+
+/**
+ * @param {Record<string, unknown>} body
+ * @returns {boolean}
+ */
+function isRecordStorageBody(body) {
+  if (String(body.entityType || '') !== 'recordStorage') {
+    return false;
+  }
+  return String(body.storageType || '') !== 'view';
+}
+
+function hasWriteCapability(body) {
+  return capabilityKeysOf(body).some((key) => /^create/i.test(key) || /^update/i.test(key));
+}
+
+function hasVendorWriteBinding(body) {
+  const ops = body.openapi && body.openapi.operations;
+  if (!ops || typeof ops !== 'object') {
+    return false;
+  }
+  return ['create', 'createBasic', 'update', 'updateBasic'].some((key) => {
+    const row = ops[key];
+    const method = String((row && row.method) || '').toUpperCase();
+    return method === 'POST' || method === 'PUT' || method === 'PATCH';
+  });
+}
+
+function applyGetOnlyLocalPersist(body) {
+  if (hasVendorWriteBinding(body) || hasWriteCapability(body)) {
+    return;
+  }
+  for (const key of ['create', 'update']) {
+    ensureCapabilityObject(body, key);
+    ensureRecordCapability(body, key);
+    stampEnterpriseOp(body, key, true);
+  }
+}
+
+function applyStaticRecordCaps(body, caps) {
+  for (const key of caps.filter((row) => row === 'list' || row === 'get')) {
+    ensureRecordCapability(body, key);
+    stampEnterpriseOp(body, key, true);
+  }
+}
+
+function applyStaticAndEnterprise(dsFiles, bid) {
+  const staticLoad = isStaticFileLoadBid(bid);
+  for (const file of dsFiles || []) {
+    const body = file.body;
+    if (!body || typeof body !== 'object') {
+      continue;
+    }
+    if (!isRecordStorageBody(body)) {
+      continue;
+    }
+    if (staticLoad) {
+      applyStaticRecordCaps(body, capabilityKeysOf(body));
+    }
+    applyGetOnlyLocalPersist(body);
+    for (const key of capabilityKeysOf(body)) {
+      stampEnterpriseOp(body, key, staticLoad);
+    }
+  }
+}
+
+module.exports = {
+  isStaticFileLoadBid,
+  hasVendorBaseUrl,
+  applyStaticAndEnterprise,
+  stampEnterpriseOp,
+  ensureRecordCapability
+};

package/lib/integration-definition/apply-system-file.js

@@ -0,0 +1,71 @@
+/**
+ * BID apply system.json body (auth none for static file-load).
+ *
+ * @fileoverview System manifest emit for integration-definition apply
+ */
+
+'use strict';
+
+const { canonicalDatasourceKeyMap } = require('./apply-datasource-keys');
+const { isStaticFileLoadBid } = require('./apply-static-enterprise');
+
+/**
+ * @param {Record<string, unknown>} bid
+ * @param {Record<string, unknown>} identity
+ * @returns {Record<string, unknown>}
+ */
+function buildSystemAuthentication(bid, identity) {
+  if (isStaticFileLoadBid(bid)) {
+    return { authType: 'none' };
+  }
+  const system = /** @type {Record<string, unknown>} */ (bid.system);
+  const refs = /** @type {Record<string, string>} */ (system.connectionRefs || {});
+  const tokenRef = refs.token || refs.apiKey || Object.values(refs)[0] || `kv://${identity.systemKey}/token`;
+  return {
+    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
+    }
+  };
+}
+
+/**
+ * @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 keyMap = canonicalDatasourceKeyMap(
+    /** @type {any[]} */ (bid.datasources) || [],
+    identity.systemKey
+  );
+  const staticLoad = isStaticFileLoadBid(bid);
+  return {
+    key: system.key,
+    displayName: system.displayName || identity.displayName,
+    description: system.description || identity.displayName,
+    type: system.type || (staticLoad ? 'custom' : 'openapi'),
+    enabled: true,
+    systemKind: system.systemKind || (staticLoad ? 'custom' : 'crm'),
+    authentication: buildSystemAuthentication(bid, identity),
+    dataSources: (/** @type {any[]} */ (bid.datasources) || []).map(
+      (d) => keyMap.get(String(d.key)) || d.key
+    )
+  };
+}
+
+module.exports = {
+  buildSystemAuthentication,
+  buildSystemFile
+};

package/lib/integration-definition/apply-test-endpoint.js

@@ -0,0 +1,89 @@
+/**
+ * Stamp credential testEndpoint from the first vendor list GET + required query mins.
+ *
+ * @fileoverview Honour OpenAPI query minimums on generated probe URLs
+ */
+
+'use strict';
+
+/**
+ * @param {Record<string, unknown>} body
+ * @returns {Record<string, unknown>}
+ */
+function listFetchQuery(body) {
+  const ops = body.execution && body.execution.cip && body.execution.cip.operations;
+  const list = ops && ops.list && typeof ops.list === 'object' ? ops.list : null;
+  const steps = list && Array.isArray(list.steps) ? list.steps : [];
+  const fetchStep = steps.find((row) => row && row.fetch && typeof row.fetch.query === 'object');
+  return fetchStep ? /** @type {Record<string, unknown>} */ (fetchStep.fetch.query) : {};
+}
+
+/**
+ * @param {Record<string, unknown>} query
+ * @returns {string}
+ */
+function probeQueryString(query) {
+  const parts = [];
+  for (const [name, value] of Object.entries(query || {})) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+    const raw = String(value);
+    if (raw.includes('{{')) {
+      continue;
+    }
+    parts.push(`${encodeURIComponent(name)}=${encodeURIComponent(raw)}`);
+  }
+  return parts.join('&');
+}
+
+/**
+ * @param {Array<{ body?: Record<string, unknown> }>} dsFiles
+ * @returns {string}
+ */
+function firstVendorListProbe(dsFiles) {
+  for (const file of dsFiles || []) {
+    const body = file && file.body;
+    const list = body && body.openapi && body.openapi.operations && body.openapi.operations.list;
+    if (!list || String(list.method || '').toUpperCase() !== 'GET') {
+      continue;
+    }
+    const opPath = String(list.path || '').trim();
+    if (!opPath || opPath.startsWith('/enterprise/')) {
+      continue;
+    }
+    const qs = probeQueryString(listFetchQuery(body));
+    return qs ? `${opPath}?${qs}` : opPath;
+  }
+  return '';
+}
+
+/**
+ * @param {Record<string, unknown>} system
+ * @param {Array<{ body?: Record<string, unknown> }>} dsFiles
+ * @returns {void}
+ */
+function stampCredentialTestEndpoint(system, dsFiles) {
+  const auth = system && system.authentication;
+  const cred = auth && auth.credential && typeof auth.credential === 'object'
+    ? auth.credential
+    : null;
+  if (!cred) {
+    return;
+  }
+  if (!cred.variables || typeof cred.variables !== 'object') {
+    cred.variables = {};
+  }
+  if (String(cred.variables.testEndpoint || '').trim()) {
+    return;
+  }
+  const probe = firstVendorListProbe(dsFiles);
+  if (probe) {
+    cred.variables.testEndpoint = probe;
+  }
+}
+
+module.exports = {
+  stampCredentialTestEndpoint,
+  firstVendorListProbe
+};