@aifabrix/builder 2.45.0 → 2.45.5

package/lib/datasource/audit-evidence-verify-helpers.js

@@ -0,0 +1,167 @@
+/**
+ * @fileoverview Helpers for audit evidence matrix verification (sub-resource validators, rows 8–9)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { checkPerExecutionRow } = require('./audit-evidence-matrix-rows');
+const {
+  normalizeAuditOperation,
+  executionsCoverExpectedOperations
+} = require('./audit-evidence-operation-aliases');
+
+/**
+ * @param {Object} input
+ * @returns {import('../api/types/audit.types').AuditEvidenceMatrixRow}
+ */
+function checkRow8CorrelationGroup(input) {
+  const row = { row: 8, status: 'failed', detail: '', code: 'correlationGroup' };
+  const items = input.executions || [];
+  if (!items.length) {
+    return {
+      ...row,
+      detail: input.correlationId
+        ? 'no executions for correlation or datasource filter'
+        : 'no correlationId and no executions',
+      code: 'correlationEmpty'
+    };
+  }
+  const expected = (input.expectedOperations || [])
+    .map(normalizeAuditOperation)
+    .filter(Boolean);
+  if (expected.length && !executionsCoverExpectedOperations(items, expected)) {
+    const ops = new Set(
+      items.map(e => normalizeAuditOperation(e && e.operation)).filter(Boolean)
+    );
+    const missing = expected.filter(op => !ops.has(op));
+    return {
+      ...row,
+      detail: `missing ops: ${missing.join(', ')}`,
+      code: 'correlationOpsMissing'
+    };
+  }
+  const opCount = new Set(
+    items.map(e => normalizeAuditOperation(e && e.operation)).filter(Boolean)
+  ).size;
+  return {
+    ...row,
+    status: 'passed',
+    detail: `correlation ops=${opCount || items.length}`,
+    code: 'correlationGroup'
+  };
+}
+
+/**
+ * Prefer executions tied to this run (by id), then correlation query, then datasource list.
+ * @param {Object} ctx
+ * @param {Array} executions
+ * @param {Array} corrQueryRows
+ * @returns {Array}
+ */
+function resolveRow8Executions(ctx, executions, corrQueryRows) {
+  const idSet = new Set(
+    (ctx.executionIds || []).map(id => String(id).trim()).filter(Boolean)
+  );
+  let byId = [];
+  if (idSet.size && executions && executions.length) {
+    byId = executions.filter(e => e && e.id && idSet.has(String(e.id)));
+  }
+  const expected = ctx.expectedOperations || [];
+  if (byId.length && executionsCoverExpectedOperations(byId, expected)) {
+    return byId;
+  }
+  if (corrQueryRows && corrQueryRows.length && executionsCoverExpectedOperations(corrQueryRows, expected)) {
+    return corrQueryRows;
+  }
+  if (byId.length) return byId;
+  if (corrQueryRows && corrQueryRows.length) return corrQueryRows;
+  return executions || [];
+}
+
+/**
+ * @param {Set<string>} traceIds
+ * @param {string[]} execIds
+ * @returns {import('../api/types/audit.types').AuditEvidenceMatrixRow}
+ */
+function checkRow9Traces(traceIds, execIds) {
+  const row = { row: 9, status: 'failed', detail: '', code: 'traceMismatch' };
+  if (!execIds.length) {
+    return { ...row, detail: 'no execution ids', code: 'auditIdsMissing' };
+  }
+  if (traceIds.size < 1) {
+    return { ...row, detail: 'no trace payloads resolved', code: 'traceEmpty' };
+  }
+  if (traceIds.size < execIds.length) {
+    return {
+      ...row,
+      detail: `distinct traces=${traceIds.size} executionIds=${execIds.length}`,
+      code: 'traceCountLow'
+    };
+  }
+  return { ...row, status: 'passed', detail: `traces=${traceIds.size} ids=${execIds.length}` };
+}
+
+function isRbacSubResourceValid(body) {
+  return !!(body && typeof body === 'object' && (body.id || body.decision || body.summary));
+}
+
+function isAbacSubResourceValid(body) {
+  return !!(body && typeof body === 'object' && (body.id || body.decision || body.traceId));
+}
+
+function isErrorsValid(body) {
+  if (Array.isArray(body)) return true;
+  if (body && typeof body === 'object' && Array.isArray(body.data)) return true;
+  return body && typeof body === 'object';
+}
+
+function isStepsValid(body) {
+  if (Array.isArray(body) && body.length > 0) return true;
+  if (body && Array.isArray(body.steps) && body.steps.length > 0) return true;
+  return body && typeof body === 'object' && Object.keys(body).length > 0;
+}
+
+/**
+ * @param {Array} executions
+ * @param {string[]} fallbackIds
+ * @returns {string[]}
+ */
+function resolveExecutionIdsForChecks(executions, fallbackIds) {
+  const fromRows = (executions || [])
+    .map(e => (e && e.id ? String(e.id).trim() : ''))
+    .filter(Boolean);
+  return [...new Set(fromRows.concat(fallbackIds || []))];
+}
+
+/**
+ * @param {Object} opts
+ * @returns {Promise<import('../api/types/audit.types').AuditEvidenceMatrixRow>}
+ */
+async function checkPerExecutionSub(opts) {
+  const { dataplaneUrl, authConfig, executionId, rowNum, label, fetcher, isValid } = opts;
+  try {
+    const body = await fetcher(dataplaneUrl, authConfig, executionId);
+    return checkPerExecutionRow(rowNum, `${label}Null`, label, body, isValid);
+  } catch (err) {
+    return {
+      row: rowNum,
+      status: 'failed',
+      detail: `${label}: ${err.message}`,
+      code: `${label}Error`
+    };
+  }
+}
+
+module.exports = {
+  checkRow8CorrelationGroup,
+  resolveRow8Executions,
+  checkRow9Traces,
+  isRbacSubResourceValid,
+  isAbacSubResourceValid,
+  isErrorsValid,
+  isStepsValid,
+  resolveExecutionIdsForChecks,
+  checkPerExecutionSub
+};

package/lib/datasource/audit-evidence-verify-matrix.js

@@ -0,0 +1,177 @@
+/**
+ * @fileoverview Build matrix rows 1–9 for audit evidence verification
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const {
+  queryExecutions,
+  queryRbacDecisions,
+  queryAbacTraces,
+  getExecutionRbac,
+  getExecutionAbac,
+  getExecutionErrors,
+  getExecutionSteps,
+  getExecutionTrace
+} = require('../api/audit.api');
+const {
+  checkRow1ExecutionsByDatasource,
+  checkRow2RbacDecisionsList,
+  checkRow3AbacTracesList
+} = require('./audit-evidence-matrix-rows');
+const {
+  operationQueryVariants,
+  executionsCoverExpectedOperations
+} = require('./audit-evidence-operation-aliases');
+const {
+  checkRow8CorrelationGroup,
+  resolveRow8Executions,
+  checkRow9Traces,
+  isRbacSubResourceValid,
+  isAbacSubResourceValid,
+  isErrorsValid,
+  isStepsValid,
+  resolveExecutionIdsForChecks,
+  checkPerExecutionSub
+} = require('./audit-evidence-verify-helpers');
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} correlationId
+ * @param {string[]} expectedOperations
+ * @returns {Promise<Array>}
+ */
+async function fetchCorrelationExecutionsByOperation(
+  dataplaneUrl,
+  authConfig,
+  correlationId,
+  expectedOperations
+) {
+  const deduped = new Map();
+  for (const rawOp of expectedOperations) {
+    const variants = operationQueryVariants(rawOp);
+    for (const op of variants) {
+      const res = await queryExecutions(dataplaneUrl, authConfig, {
+        correlationId,
+        operation: op,
+        pageSize: 20
+      });
+      for (const row of res.data || []) {
+        if (row && row.id) deduped.set(String(row.id), row);
+      }
+    }
+  }
+  const merged = [...deduped.values()];
+  return executionsCoverExpectedOperations(merged, expectedOperations) ? merged : [];
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object} polled
+ * @param {number} minExpected
+ * @returns {Promise<import('../api/types/audit.types').AuditEvidenceMatrixRow[]>}
+ */
+async function buildListMatrixRows(ctx, polled, minExpected) {
+  const executions = polled.data || [];
+  const { dataplaneUrl, authConfig } = ctx;
+  const totalItems =
+    polled.meta && polled.meta.totalItems !== undefined
+      ? polled.meta.totalItems
+      : executions.length;
+  const rows = [
+    checkRow1ExecutionsByDatasource({
+      executions,
+      totalItems,
+      minExpected
+    })
+  ];
+  const rbacList = await queryRbacDecisions(dataplaneUrl, authConfig, {
+    targetDatasourceKey: ctx.datasourceKey,
+    pageSize: 100
+  });
+  rows.push(
+    checkRow2RbacDecisionsList({
+      rbacItems: rbacList.data,
+      totalItems: rbacList.meta && rbacList.meta.totalItems
+    })
+  );
+  const abacList = await queryAbacTraces(dataplaneUrl, authConfig, {
+    datasourceKey: ctx.datasourceKey,
+    pageSize: 100
+  });
+  rows.push(
+    checkRow3AbacTracesList({
+      abacItems: abacList.data,
+      totalItems: abacList.meta && abacList.meta.totalItems
+    })
+  );
+  return rows;
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Array} executions
+ * @param {string[]} executionIds
+ * @returns {Promise<{ rows: import('../api/types/audit.types').AuditEvidenceMatrixRow[], execIds: string[] }>}
+ */
+async function buildPerExecutionAndTailRows(ctx, executions, executionIds) {
+  const { dataplaneUrl, authConfig } = ctx;
+  const execIds = resolveExecutionIdsForChecks(executions, executionIds);
+  const sampleId = execIds[0];
+  const base = { dataplaneUrl, authConfig, executionId: sampleId };
+  const rows = await Promise.all([
+    checkPerExecutionSub({ ...base, rowNum: 4, label: 'rbac', fetcher: getExecutionRbac, isValid: isRbacSubResourceValid }),
+    checkPerExecutionSub({ ...base, rowNum: 5, label: 'abac', fetcher: getExecutionAbac, isValid: isAbacSubResourceValid }),
+    checkPerExecutionSub({ ...base, rowNum: 6, label: 'errors', fetcher: getExecutionErrors, isValid: isErrorsValid }),
+    checkPerExecutionSub({ ...base, rowNum: 7, label: 'steps', fetcher: getExecutionSteps, isValid: isStepsValid })
+  ]);
+
+  let corrQueryRows = [];
+  if (ctx.correlationId) {
+    const corr = await queryExecutions(dataplaneUrl, authConfig, {
+      correlationId: ctx.correlationId,
+      pageSize: 100
+    });
+    corrQueryRows = corr.data || [];
+  }
+  let row8Pool = corrQueryRows.length ? corrQueryRows : executions;
+  const expected = ctx.expectedOperations || [];
+  if (expected.length && ctx.correlationId) {
+    const byOp = await fetchCorrelationExecutionsByOperation(
+      dataplaneUrl,
+      authConfig,
+      ctx.correlationId,
+      expected
+    );
+    if (byOp.length) row8Pool = byOp;
+  }
+  const row8Executions = resolveRow8Executions(ctx, executions, row8Pool);
+  rows.push(
+    checkRow8CorrelationGroup({
+      correlationId: ctx.correlationId,
+      executions: row8Executions,
+      expectedOperations: ctx.expectedOperations
+    })
+  );
+
+  const traceIds = new Set();
+  for (const id of execIds.slice(0, Math.min(execIds.length, 12))) {
+    try {
+      const tr = await getExecutionTrace(dataplaneUrl, authConfig, id);
+      if (tr && tr.executionId) traceIds.add(String(tr.executionId));
+      else if (tr && tr.id) traceIds.add(String(tr.id));
+    } catch {
+      /* row 9 may fail */
+    }
+  }
+  rows.push(checkRow9Traces(traceIds, execIds));
+  return { rows, execIds };
+}
+
+module.exports = {
+  buildListMatrixRows,
+  buildPerExecutionAndTailRows
+};

package/lib/datasource/audit-evidence-verify.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Run Plan 407.1 nine-row audit evidence matrix against dataplane APIs
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { queryExecutions } = require('../api/audit.api');
+const { pollExecutionsUntilReady } = require('./audit-evidence-poll');
+const {
+  buildListMatrixRows,
+  buildPerExecutionAndTailRows
+} = require('./audit-evidence-verify-matrix');
+const { checkRow8CorrelationGroup, checkRow9Traces } = require('./audit-evidence-verify-helpers');
+
+/**
+ * @param {Object} ctx
+ * @returns {number}
+ */
+/**
+ * E2E runs tag executions with testRunId as correlationId; prefer that for list poll.
+ * @param {Object} ctx
+ * @returns {Object}
+ */
+function buildExecutionsPollQuery(ctx) {
+  const base = { pageSize: 100, sort: '-startedAt' };
+  if (ctx.correlationId) {
+    return { ...base, correlationId: ctx.correlationId };
+  }
+  return { ...base, datasourceKey: ctx.datasourceKey };
+}
+
+function resolveMinExpected(ctx) {
+  const fromOps = ctx.expectedOperations && ctx.expectedOperations.length;
+  const fromIds = ctx.executionIds && ctx.executionIds.length;
+  if (fromIds && fromOps) {
+    return Math.max(1, Math.min(fromOps, fromIds));
+  }
+  return Math.max(1, fromOps || fromIds || 1);
+}
+
+/**
+ * @param {string} datasourceKey
+ * @param {Object} ctx
+ * @returns {import('../api/types/audit.types').AuditEvidenceVerification}
+ */
+function failedMissingIds(datasourceKey, ctx) {
+  return {
+    status: 'failed',
+    datasourceKey,
+    correlationId: ctx.correlationId || null,
+    executionIds: [],
+    matrix: [
+      {
+        row: 0,
+        status: 'failed',
+        detail: 'missing audit.executionIds in envelope',
+        code: 'auditIdsMissing'
+      }
+    ]
+  };
+}
+
+/**
+ * @param {Object} ctx
+ * @returns {Promise<import('../api/types/audit.types').AuditEvidenceVerification>}
+ */
+async function verifyAuditEvidenceMatrix(ctx) {
+  const datasourceKey = ctx.datasourceKey || '';
+  const executionIds = Array.isArray(ctx.executionIds) ? ctx.executionIds : [];
+  if (!executionIds.length && !ctx.correlationId) {
+    return failedMissingIds(datasourceKey, ctx);
+  }
+
+  const { dataplaneUrl, authConfig } = ctx;
+  const minExpected = resolveMinExpected(ctx);
+  const execQuery = buildExecutionsPollQuery(ctx);
+  const polled = await pollExecutionsUntilReady({
+    fetchExecutions: () => queryExecutions(dataplaneUrl, authConfig, execQuery),
+    minExpected,
+    executionIds,
+    maxWaitMs: ctx.maxWaitMs,
+    intervalMs: ctx.intervalMs
+  });
+
+  const executions = polled.data || [];
+  const matrix = await buildListMatrixRows(ctx, polled, minExpected);
+  const tail = await buildPerExecutionAndTailRows(ctx, executions, executionIds);
+  matrix.push(...tail.rows);
+
+  const passed = matrix.every(r => r.status === 'passed');
+  return {
+    status: passed ? 'passed' : 'failed',
+    datasourceKey,
+    correlationId: ctx.correlationId || null,
+    executionIds: tail.execIds,
+    matrix
+  };
+}
+
+module.exports = {
+  verifyAuditEvidenceMatrix,
+  buildExecutionsPollQuery,
+  resolveMinExpected,
+  checkRow8CorrelationGroup,
+  checkRow9Traces
+};

package/lib/datasource/bulk-loader-run-batches.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview Batch upload loop for datasource load (plan 144)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { bulkSyncRecords } = require('../api/records-bulk.api');
+const { withTransientRetry, errorStatusCode } = require('./bulk-loader-service-retry');
+
+/**
+ * @param {Object} state
+ * @param {number} index
+ * @param {Error} err
+ * @param {Object[]} batchRecords
+ */
+function recordBatchFailure(state, index, err, batchRecords) {
+  state.batches.push({
+    index: index + 1,
+    total: state.chunkCount,
+    error: err.message || String(err),
+    statusCode: errorStatusCode(err),
+    recordCount: batchRecords.length,
+    failed: batchRecords.map(r => ({ key: r.key, message: err.message || String(err) }))
+  });
+  state.totals.failedCount += batchRecords.length;
+}
+
+/**
+ * @param {Object} state
+ * @param {number} index
+ * @param {Object} response
+ * @param {Object[]} batchRecords
+ */
+function recordBatchSuccess(state, index, response, batchRecords) {
+  const inserted = response.insertedCount || 0;
+  const updated = response.updatedCount || 0;
+  const processed = response.totalProcessed || batchRecords.length;
+  const failedInBatch = Math.max(0, batchRecords.length - processed);
+
+  state.batches.push({
+    index: index + 1,
+    total: state.chunkCount,
+    insertedCount: inserted,
+    updatedCount: updated,
+    totalProcessed: processed,
+    failed: failedInBatch > 0 ? [{ message: 'Some records were not processed' }] : []
+  });
+  state.totals.insertedCount += inserted;
+  state.totals.updatedCount += updated;
+  state.totals.failedCount += failedInBatch;
+}
+
+/**
+ * @async
+ * @param {Object} params
+ * @returns {Promise<{ batches: Object[], totals: Object }>}
+ */
+async function uploadRecordBatches(params) {
+  const { chunks, syncType, dataplaneUrl, datasourceKey, authConfig } = params;
+  const state = {
+    batches: [],
+    totals: { insertedCount: 0, updatedCount: 0, failedCount: 0 },
+    chunkCount: chunks.length
+  };
+
+  for (let i = 0; i < chunks.length; i += 1) {
+    const batchRecords = chunks[i];
+    const body = { syncType, sync: false, records: batchRecords };
+    try {
+      const response = await withTransientRetry(() =>
+        bulkSyncRecords(dataplaneUrl, datasourceKey, authConfig, body)
+      );
+      recordBatchSuccess(state, i, response, batchRecords);
+    } catch (err) {
+      recordBatchFailure(state, i, err, batchRecords);
+    }
+  }
+
+  return { batches: state.batches, totals: state.totals };
+}
+
+module.exports = {
+  uploadRecordBatches,
+  recordBatchFailure,
+  recordBatchSuccess
+};

package/lib/datasource/bulk-loader-service-retry.js

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Retry helpers for bulk loader (plan 144)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const MAX_RETRIES = 3;
+const RETRY_STATUS = new Set([429, 500, 502, 503, 504]);
+
+/**
+ * @param {Error} err
+ * @returns {number|null}
+ */
+function errorStatusCode(err) {
+  if (!err || typeof err !== 'object') return null;
+  if (typeof err.statusCode === 'number') return err.statusCode;
+  if (err.response && typeof err.response.status === 'number') return err.response.status;
+  return null;
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * @async
+ * @param {Function} fn
+ * @returns {Promise<*>}
+ */
+async function withTransientRetry(fn) {
+  let lastErr;
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt += 1) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      const code = errorStatusCode(err);
+      if (!code || !RETRY_STATUS.has(code) || attempt >= MAX_RETRIES - 1) {
+        throw err;
+      }
+      await sleep(500 * (attempt + 1));
+    }
+  }
+  throw lastErr;
+}
+
+module.exports = {
+  withTransientRetry,
+  errorStatusCode
+};