@aifabrix/builder 2.44.6 → 2.45.5

package/lib/protection/paths.js

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview Protection manifest directory under repo `integration/.protection/`.
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getAppsMaterializationParent,
+  getCwdIntegrationRoot
+} = require('../utils/paths');
+const { nodeFs } = require('../internal/node-fs');
+
+/**
+ * Walk upward from cwd for the nearest directory containing `integration/`.
+ *
+ * @returns {string|null} Absolute path to `integration/` or null
+ */
+function findNearestIntegrationRootFromCwd() {
+  const disk = nodeFs();
+  let walk = path.resolve(process.cwd());
+  for (let i = 0; i < 64; i += 1) {
+    const integrationDir = path.join(walk, 'integration');
+    try {
+      if (disk.existsSync(integrationDir)) {
+        const st = disk.statSync(integrationDir);
+        if (st && typeof st.isDirectory === 'function' && st.isDirectory()) {
+          return integrationDir;
+        }
+      }
+    } catch {
+      // ignore
+    }
+    const parent = path.dirname(walk);
+    if (parent === walk) {
+      break;
+    }
+    walk = parent;
+  }
+  return null;
+}
+
+/**
+ * Canonical repo-local protection root: `integration/.protection/`.
+ *
+ * @returns {string}
+ */
+function getRepoProtectionRoot() {
+  const cwdInt = getCwdIntegrationRoot();
+  if (cwdInt) {
+    return path.join(cwdInt, '.protection');
+  }
+  const materializationParent = path.resolve(getAppsMaterializationParent());
+  const nearest = findNearestIntegrationRootFromCwd();
+  if (nearest) {
+    const resolvedNearest = path.resolve(nearest);
+    if (
+      resolvedNearest === materializationParent ||
+      resolvedNearest.startsWith(`${materializationParent}${path.sep}`)
+    ) {
+      return path.join(resolvedNearest, '.protection');
+    }
+  }
+  return path.join(materializationParent, 'integration', '.protection');
+}
+
+/**
+ * @returns {string}
+ */
+function getLegacyProtectionRoot() {
+  return path.join(getAppsMaterializationParent(), '.protection');
+}
+
+/**
+ * @param {string} root
+ * @returns {boolean}
+ */
+function protectionRootHasManifestFiles(root) {
+  if (!root || !fs.existsSync(root)) {
+    return false;
+  }
+  try {
+    return fs.readdirSync(root).some((name) => /\.(yaml|yml|json)$/i.test(name));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @returns {string} Absolute path to protection manifests directory
+ */
+function getProtectionRoot() {
+  const explicit = process.env.AIFABRIX_PROTECTION_ROOT;
+  if (explicit && typeof explicit === 'string' && explicit.trim()) {
+    return path.resolve(explicit.trim());
+  }
+
+  const legacyFlag =
+    process.env.AIFABRIX_PROTECTION_LEGACY === '1' ||
+    String(process.env.AIFABRIX_PROTECTION_LEGACY || '').toLowerCase() === 'true';
+
+  const repoRoot = getRepoProtectionRoot();
+  const legacyRoot = getLegacyProtectionRoot();
+
+  if (legacyFlag) {
+    return legacyRoot;
+  }
+
+  const repoHas = protectionRootHasManifestFiles(repoRoot);
+  const legacyHas = protectionRootHasManifestFiles(legacyRoot);
+
+  if (!repoHas && legacyHas && legacyRoot !== repoRoot) {
+    return legacyRoot;
+  }
+
+  return repoRoot;
+}
+
+/**
+ * Human-readable folder label for batch protection TTY output.
+ *
+ * @returns {{ root: string, label: string, usingLegacy: boolean, migrationHint: string|null }}
+ */
+function describeProtectionRoot() {
+  const root = getProtectionRoot();
+  const legacyRoot = getLegacyProtectionRoot();
+  const repoRoot = getRepoProtectionRoot();
+  const usingLegacy = path.resolve(root) === path.resolve(legacyRoot);
+  const legacyHas = protectionRootHasManifestFiles(legacyRoot);
+  const repoHas = protectionRootHasManifestFiles(repoRoot);
+
+  let label = 'integration/.protection';
+  if (usingLegacy) {
+    label = 'work/.protection (legacy)';
+  } else if (process.env.AIFABRIX_PROTECTION_ROOT) {
+    label = 'custom';
+  }
+
+  let migrationHint = null;
+  if (usingLegacy && legacyHas) {
+    migrationHint = `Move manifests to ${repoRoot} (git-friendly integration/.protection/).`;
+  } else if (!usingLegacy && legacyHas && !repoHas) {
+    migrationHint = `Legacy manifests remain under ${legacyRoot}; migrate to ${repoRoot}.`;
+  }
+
+  return { root, label, usingLegacy, migrationHint };
+}
+
+module.exports = {
+  getProtectionRoot,
+  describeProtectionRoot,
+  getRepoProtectionRoot,
+  getLegacyProtectionRoot,
+  findNearestIntegrationRootFromCwd
+};

package/lib/protection/preflight-datasource-ready.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Preflight: datasource must exist on dataplane before protection upload.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getDatasource } = require('../api/datasources-core.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} datasourceKey
+ * @returns {Promise<void>}
+ */
+async function assertDatasourceExistsOnDataplane(dataplaneUrl, authConfig, datasourceKey) {
+  const key = String(datasourceKey || '').trim();
+  if (!key) {
+    throw new Error('spec.datasourceKey is required');
+  }
+  const res = await getDatasource(dataplaneUrl, key, authConfig);
+  const row = unwrapApiData(res);
+  if (!row || (res && res.success === false)) {
+    throw new Error(
+      `Datasource "${key}" is not deployed on the dataplane. Run aifabrix deploy <app> first.`
+    );
+  }
+}
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {Object} manifest
+ * @returns {Promise<void>}
+ */
+async function preflightDatasourceReady(dataplaneUrl, authConfig, manifest) {
+  const ds = String(manifest?.spec?.datasourceKey || '').trim();
+  await assertDatasourceExistsOnDataplane(dataplaneUrl, authConfig, ds);
+}
+
+module.exports = {
+  assertDatasourceExistsOnDataplane,
+  preflightDatasourceReady
+};

package/lib/protection/protection-create-probe-lines.js

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview TTY line builders for protection create probes (keeps probe async functions small).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const {
+  sectionTitle,
+  headerKeyValue,
+  metadata,
+  formatProgress,
+  formatSuccessLine
+} = require('../utils/cli-test-layout-chalk');
+
+const SEP = chalk.gray('────────────────────────────────────────');
+
+/**
+ * @param {string} key
+ * @returns {string[]}
+ */
+function startDatasourceProbeLines(key) {
+  return [sectionTitle('Datasource (dataplane)'), SEP, formatProgress(`Fetching datasource "${key}"…`)];
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} row
+ * @param {string} key
+ * @param {string} dataplaneUrl
+ */
+function appendDatasourceCoreFields(lines, row, key, dataplaneUrl) {
+  lines.push(formatSuccessLine(`Datasource "${key}" found`));
+  lines.push(metadata(`Dataplane: ${dataplaneUrl}`));
+  lines.push(headerKeyValue('Key:', row.key ?? key));
+  lines.push(headerKeyValue('Display name:', row.displayName ?? '—'));
+  lines.push(headerKeyValue('System key:', row.systemKey ?? '—'));
+  const ver = row.version;
+  lines.push(headerKeyValue('Version:', ver !== undefined && ver !== null ? String(ver) : '—'));
+  lines.push(headerKeyValue('Enabled:', String(row.enabled !== false)));
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} row
+ */
+function appendDatasourceOptionalTypes(lines, row) {
+  if (row.entityType) {
+    lines.push(headerKeyValue('Entity type:', String(row.entityType)));
+  }
+  if (row.resourceType) {
+    lines.push(headerKeyValue('Resource type:', String(row.resourceType)));
+  }
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} row
+ */
+function appendDatasourceVerboseBlock(lines, row) {
+  const pick = ['id', 'key', 'displayName', 'systemKey', 'version', 'enabled', 'entityType', 'resourceType'];
+  const extra = {};
+  for (const p of pick) {
+    if (row[p] !== undefined) {
+      extra[p] = row[p];
+    }
+  }
+  lines.push('');
+  lines.push(chalk.gray('Verbose (subset):'));
+  lines.push(chalk.gray(JSON.stringify(extra, null, 2)));
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} row
+ * @param {string} key
+ * @param {string} dataplaneUrl
+ * @param {Object} opts
+ */
+function appendDatasourceSuccessDetail(lines, row, key, dataplaneUrl, opts) {
+  appendDatasourceCoreFields(lines, row, key, dataplaneUrl);
+  appendDatasourceOptionalTypes(lines, row);
+  if (opts.verbose && row) {
+    appendDatasourceVerboseBlock(lines, row);
+  }
+  lines.push('');
+}
+
+/**
+ * @param {string} key
+ * @returns {string[]}
+ */
+function startDimensionProbeLines(key) {
+  return [
+    sectionTitle('Dimension (Controller catalog)'),
+    SEP,
+    formatProgress(`Fetching dimension "${key}"…`)
+  ];
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} row
+ * @param {string} controllerUrl
+ * @param {Object} opts
+ */
+function appendDimensionSuccessDetail(lines, row, controllerUrl, opts) {
+  lines.push(formatSuccessLine(`Dimension "${row.key}" found`));
+  lines.push(metadata(`Controller: ${controllerUrl}`));
+  lines.push(headerKeyValue('Key:', row.key));
+  lines.push(headerKeyValue('Display:', row.displayName ?? '—'));
+  lines.push(headerKeyValue('Data type:', row.dataType ?? '—'));
+  lines.push(headerKeyValue('Value type:', row.valueType ?? 'static'));
+  lines.push(headerKeyValue('Required:', String(row.isRequired === true)));
+  if (Array.isArray(row.dimensionValues) && row.dimensionValues.length > 0) {
+    lines.push(
+      headerKeyValue('Catalog values:', `${row.dimensionValues.length} (static/baseline)`)
+    );
+  } else if (row.valueType === 'dynamic' || row.valueType === 'both') {
+    lines.push(headerKeyValue('Catalog values:', '— (dynamic / projection)'));
+  }
+  if (opts.verbose && Array.isArray(row.dimensionValues) && row.dimensionValues.length) {
+    lines.push('');
+    lines.push(chalk.gray('Sample values (first 5):'));
+    row.dimensionValues.slice(0, 5).forEach((v) => {
+      const val = v && v.value !== undefined && v.value !== null ? String(v.value) : '—';
+      const dn = v?.displayName ? ` (${v.displayName})` : '';
+      lines.push(chalk.gray(`  ${val}${dn}`));
+    });
+  }
+  lines.push('');
+}
+
+module.exports = {
+  SEP,
+  startDatasourceProbeLines,
+  appendDatasourceSuccessDetail,
+  startDimensionProbeLines,
+  appendDimensionSuccessDetail
+};

package/lib/protection/protection-create-probes.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Online probes for `protection create` (dataplane datasource + Controller dimension).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getDatasource } = require('../api/datasources-core.api');
+const { getDimension } = require('../api/dimensions.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const {
+  startDatasourceProbeLines,
+  appendDatasourceSuccessDetail,
+  startDimensionProbeLines,
+  appendDimensionSuccessDetail
+} = require('./protection-create-probe-lines');
+
+/**
+ * @param {*} response
+ * @returns {*}
+ */
+function unwrapControllerDimension(response) {
+  const d = response?.data?.data ?? response?.data ?? response;
+  return d;
+}
+
+/**
+ * @param {string[]} lines
+ * @param {string} msg
+ * @returns {never}
+ */
+function throwProbe(lines, msg) {
+  const err = new Error(msg);
+  err.probeLines = lines;
+  throw err;
+}
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} datasourceKey
+ * @param {Object} opts
+ * @returns {Promise<Object>}
+ */
+async function probeDatasourceForProtectionCreate(dataplaneUrl, authConfig, datasourceKey, opts = {}) {
+  const key = String(datasourceKey || '').trim();
+  const lines = startDatasourceProbeLines(key);
+  const res = await getDatasource(dataplaneUrl, key, authConfig);
+  if (res && res.success === false) {
+    const msg = res.formattedError || res.error || `Datasource "${key}" request failed`;
+    throwProbe(lines, typeof msg === 'string' ? msg : 'Datasource probe failed');
+  }
+  const row = unwrapApiData(res);
+  if (!row) {
+    throwProbe(
+      lines,
+      `Datasource "${key}" not found or not readable on the dataplane. Deploy the integration first.`
+    );
+  }
+  appendDatasourceSuccessDetail(lines, row, key, dataplaneUrl, opts);
+  return { row, lines };
+}
+
+/**
+ * @param {string} controllerUrl
+ * @param {Object} authConfig
+ * @param {string} dimensionKey
+ * @param {Object} opts
+ * @returns {Promise<Object>}
+ */
+async function probeDimensionForProtectionCreate(controllerUrl, authConfig, dimensionKey, opts = {}) {
+  const key = String(dimensionKey || '').trim();
+  const lines = startDimensionProbeLines(key);
+  const res = await getDimension(controllerUrl, authConfig, key, { includeValues: opts.verbose === true });
+  if (res && res.success === false) {
+    const msg = res.formattedError || res.error || `Dimension "${key}" request failed`;
+    throwProbe(lines, typeof msg === 'string' ? msg : 'Dimension probe failed');
+  }
+  const row = unwrapControllerDimension(res);
+  if (!row || !row.key) {
+    throwProbe(
+      lines,
+      `Dimension "${key}" not found in the Controller catalog. Create it with: aifabrix dimension create …`
+    );
+  }
+  appendDimensionSuccessDetail(lines, row, controllerUrl, opts);
+  return { row, lines };
+}
+
+module.exports = {
+  probeDatasourceForProtectionCreate,
+  probeDimensionForProtectionCreate,
+  unwrapControllerDimension
+};