@aifabrix/builder 2.54.1 → 2.55.0

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
+};

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
+};