@aifabrix/builder 2.49.2 → 2.50.0

package/lib/evidence/evidence-service.js

@@ -0,0 +1,392 @@
+/**
+ * @fileoverview Evidence Fabrix command implementations.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const { resolveEvidenceDataplaneContext } = require('./dataplane-context');
+const {
+  listEvidence,
+  getEvidence,
+  insertEvidence,
+  updateEvidence,
+  deleteEvidence,
+  loadEvidenceBulk
+} = require('../api/evidence.api');
+const {
+  formatEvidenceListTTY,
+  formatEvidenceGetTTY,
+  formatEvidenceLoadSummaryTTY,
+  formatEvidenceExportSummaryTTY
+} = require('./evidence-display');
+const { formatWarningLine } = require('../utils/cli-layout-chalk');
+
+const DEFAULT_BULK_FILE = path.join('.evidence', 'evidence.json');
+
+/**
+ * @param {Error} err
+ * @returns {number}
+ */
+function exitCodeForEvidenceError(err) {
+  const message = String(err?.message || err);
+  if (/auth|login|token|version|unreachable/i.test(message)) {
+    return 3;
+  }
+  if (err?.status === 409) {
+    return 1;
+  }
+  return 1;
+}
+
+/**
+ * @param {Error} err
+ * @returns {string}
+ */
+function formatDeleteError(err) {
+  if (err?.status === 409) {
+    return 'Evidence is in use by runtime execution and cannot be deleted.';
+  }
+  return err?.message || String(err);
+}
+
+/**
+ * @param {Object} opts
+ * @returns {Promise<{ environment: string, controllerUrl: string, dataplaneUrl: string, authConfig: Object }>}
+ */
+async function resolveContext(opts) {
+  return resolveEvidenceDataplaneContext(opts);
+}
+
+/**
+ * @param {Object} opts
+ * @returns {import('../api/types/evidence.types').EvidenceListParams}
+ */
+function buildListParams(opts) {
+  const params = {};
+  if (opts.resourceType) params.resourceType = opts.resourceType;
+  if (opts.roleKey) params.roleKey = opts.roleKey;
+  if (opts.generic === true) params.genericOnly = true;
+  if (opts.status) params.status = opts.status;
+  return params;
+}
+
+/**
+ * @param {Object} opts
+ * @returns {Promise<Object>}
+ */
+async function readPayloadFile(opts) {
+  const filePath = path.resolve(opts.file || '');
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  if (Array.isArray(parsed)) {
+    throw new Error('Expected a single evidence object in --file for this command.');
+  }
+  return parsed;
+}
+
+/**
+ * @param {Object} opts
+ * @returns {Object}
+ */
+function buildRequiredInsertFields(opts) {
+  const resourceType = String(opts.resourceType || '').trim();
+  const title = String(opts.title || '').trim();
+  const when = String(opts.when || '').trim();
+  const expectedBehavior = String(opts.expectedBehavior || '').trim();
+  if (!resourceType || !title || !when || !expectedBehavior) {
+    throw new Error(
+      'Insert requires --resource-type, --title, --when, and --expected-behavior (or --file).'
+    );
+  }
+  return { resourceType, title, when, expectedBehavior };
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} required
+ * @returns {Object}
+ */
+function applyOptionalInsertFields(opts, required) {
+  const payload = { ...required };
+  if (opts.roleKey) payload.roleKey = String(opts.roleKey).trim();
+  if (opts.generic === true) payload.roleKey = null;
+  if (opts.description) payload.description = String(opts.description);
+  if (opts.order !== undefined && opts.order !== null) payload.order = Number(opts.order);
+  if (opts.status) payload.status = opts.status;
+  return payload;
+}
+
+/**
+ * @param {Object} opts
+ * @returns {Promise<Object>|Object}
+ */
+function buildInsertPayloadFromFlags(opts) {
+  if (opts.file) {
+    return readPayloadFile(opts);
+  }
+  return applyOptionalInsertFields(opts, buildRequiredInsertFields(opts));
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} logger
+ * @returns {Promise<number>}
+ */
+async function runEvidenceList(opts, logger) {
+  const ctx = await resolveContext(opts);
+  const rows = await listEvidence(ctx.dataplaneUrl, ctx.authConfig, buildListParams(opts), {
+    controllerUrl: ctx.controllerUrl
+  });
+  if (opts.json) {
+    logger.log(JSON.stringify({ data: rows }, null, 2));
+  } else {
+    logger.log(formatEvidenceListTTY(rows));
+  }
+  return 0;
+}
+
+/**
+ * @param {string} evidenceId
+ * @param {Object} opts
+ * @param {Object} logger
+ * @returns {Promise<number>}
+ */
+async function runEvidenceGet(evidenceId, opts, logger) {
+  const ctx = await resolveContext(opts);
+  const row = await getEvidence(ctx.dataplaneUrl, ctx.authConfig, evidenceId, {
+    controllerUrl: ctx.controllerUrl
+  });
+  if (opts.json) {
+    logger.log(JSON.stringify(row, null, 2));
+  } else {
+    logger.log(formatEvidenceGetTTY(row));
+  }
+  return 0;
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} logger
+ * @returns {Promise<number>}
+ */
+async function runEvidenceInsert(opts, logger) {
+  const payload = await buildInsertPayloadFromFlags(opts);
+  const ctx = await resolveContext(opts);
+  const row = await insertEvidence(ctx.dataplaneUrl, ctx.authConfig, payload, {
+    controllerUrl: ctx.controllerUrl
+  });
+  if (opts.json) {
+    logger.log(JSON.stringify(row, null, 2));
+  } else {
+    logger.log(formatEvidenceGetTTY(row));
+  }
+  return 0;
+}
+
+/**
+ * @param {string} evidenceId
+ * @param {Object} opts
+ * @param {Object} logger
+ * @returns {Promise<number>}
+ */
+async function runEvidenceUpdate(evidenceId, opts, logger) {
+  const payload = opts.file ? await readPayloadFile(opts) : {};
+  if (opts.roleKey) payload.roleKey = String(opts.roleKey).trim();
+  if (opts.generic === true) payload.roleKey = null;
+  if (opts.title) payload.title = String(opts.title).trim();
+  if (opts.description) payload.description = String(opts.description);
+  if (opts.when) payload.when = String(opts.when).trim();
+  if (opts.expectedBehavior) payload.expectedBehavior = String(opts.expectedBehavior).trim();
+  if (opts.order !== undefined && opts.order !== null) payload.order = Number(opts.order);
+  if (opts.status) payload.status = opts.status;
+  if (!Object.keys(payload).length) {
+    throw new Error('Update requires --file or at least one field flag.');
+  }
+  const ctx = await resolveContext(opts);
+  const row = await updateEvidence(ctx.dataplaneUrl, ctx.authConfig, evidenceId, payload, {
+    controllerUrl: ctx.controllerUrl
+  });
+  if (opts.json) {
+    logger.log(JSON.stringify(row, null, 2));
+  } else {
+    logger.log(formatEvidenceGetTTY(row));
+  }
+  return 0;
+}
+
+/**
+ * @param {string} evidenceId
+ * @param {Object} opts
+ * @param {Object} logger
+ * @returns {Promise<number>}
+ */
+async function runEvidenceDelete(evidenceId, opts, logger) {
+  if (!opts.yes) {
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: `Delete evidence '${evidenceId}'? (only succeeds when not referenced by runtime)`,
+        default: false
+      }
+    ]);
+    if (!confirmed) {
+      logger.log(chalk.gray('Delete cancelled.'));
+      return 0;
+    }
+  }
+  const ctx = await resolveContext(opts);
+  try {
+    await deleteEvidence(ctx.dataplaneUrl, ctx.authConfig, evidenceId, {
+      controllerUrl: ctx.controllerUrl
+    });
+  } catch (err) {
+    throw new Error(formatDeleteError(err));
+  }
+  if (opts.json) {
+    logger.log(JSON.stringify({ deleted: evidenceId }, null, 2));
+  } else {
+    logger.log(formatWarningLine(`Deleted evidence ${evidenceId}.`));
+  }
+  return 0;
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Object[]}
+ */
+function readBulkEvidenceFile(filePath) {
+  const resolved = path.resolve(filePath || DEFAULT_BULK_FILE);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+  const parsed = JSON.parse(fs.readFileSync(resolved, 'utf8'));
+  if (!Array.isArray(parsed)) {
+    throw new Error('Bulk file must be a JSON array of evidence objects.');
+  }
+  return parsed;
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object[]} rows
+ * @param {Object} [options]
+ * @param {boolean} [options.dryRun]
+ * @returns {Promise<{ inserted: number, updated: number }>}
+ */
+async function applyEvidenceBulkRows(ctx, rows, options = {}) {
+  const result = await loadEvidenceBulk(ctx.dataplaneUrl, ctx.authConfig, rows, {
+    controllerUrl: ctx.controllerUrl,
+    dryRun: Boolean(options.dryRun)
+  });
+  return { inserted: result.inserted, updated: result.updated };
+}
+
+/**
+ * @param {Object} summary
+ * @param {Object} opts
+ * @param {Object} logger
+ */
+function logEvidenceLoadDryRun(summary, opts, logger) {
+  if (opts.json) {
+    logger.log(JSON.stringify({ dryRun: true, ...summary }, null, 2));
+    return;
+  }
+  logger.log(
+    formatWarningLine(
+      `Dry run: ${summary.inserted} would insert, ${summary.updated} would update `
+        + `(${summary.rowCount} row(s) in ${summary.file})`
+    )
+  );
+}
+
+/**
+ * @param {Object} summary
+ * @param {Object} opts
+ * @param {Object} logger
+ */
+function logEvidenceLoadResult(summary, opts, logger) {
+  if (opts.json) {
+    logger.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  logger.log(formatEvidenceLoadSummaryTTY(summary));
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} logger
+ * @returns {Promise<number>}
+ */
+async function runEvidenceLoad(opts, logger) {
+  const filePath = path.resolve(opts.file || DEFAULT_BULK_FILE);
+  const rows = readBulkEvidenceFile(filePath);
+  const summary = { inserted: 0, updated: 0, skipped: 0, file: filePath, rowCount: rows.length };
+
+  if (opts.dryRun) {
+    const ctx = await resolveContext(opts);
+    const counts = await applyEvidenceBulkRows(ctx, rows, { dryRun: true });
+    summary.inserted = counts.inserted;
+    summary.updated = counts.updated;
+    logEvidenceLoadDryRun(summary, opts, logger);
+    return 0;
+  }
+
+  const ctx = await resolveContext(opts);
+  const counts = await applyEvidenceBulkRows(ctx, rows);
+  summary.inserted = counts.inserted;
+  summary.updated = counts.updated;
+  logEvidenceLoadResult(summary, opts, logger);
+  return 0;
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} logger
+ * @returns {Promise<number>}
+ */
+async function runEvidenceExport(opts, logger) {
+  const ctx = await resolveContext(opts);
+  const rows = await listEvidence(ctx.dataplaneUrl, ctx.authConfig, buildListParams(opts), {
+    controllerUrl: ctx.controllerUrl
+  });
+  const sorted = [...rows].sort((left, right) => {
+    const rt = String(left.resourceType).localeCompare(String(right.resourceType));
+    if (rt !== 0) return rt;
+    const leftRole = left.roleKey || '';
+    const rightRole = right.roleKey || '';
+    const roleCmp = leftRole.localeCompare(rightRole);
+    if (roleCmp !== 0) return roleCmp;
+    return (left.order || 0) - (right.order || 0);
+  });
+  const filePath = path.resolve(opts.file || DEFAULT_BULK_FILE);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(sorted, null, 2)}\n`, 'utf8');
+  const summary = { count: sorted.length, file: filePath };
+  if (opts.json) {
+    logger.log(JSON.stringify(summary, null, 2));
+  } else {
+    logger.log(formatEvidenceExportSummaryTTY(summary));
+  }
+  return 0;
+}
+
+module.exports = {
+  DEFAULT_BULK_FILE,
+  exitCodeForEvidenceError,
+  runEvidenceList,
+  runEvidenceGet,
+  runEvidenceInsert,
+  runEvidenceUpdate,
+  runEvidenceDelete,
+  runEvidenceLoad,
+  runEvidenceExport
+};