dsh-logicprobe 0.9.0 → 1.0.0

package/lib/data-engine.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { REPORT_SCHEMAS, verdictOfFindings } from './engine.js';
 export const DATA_ENGINE_SCHEMA_VERSION = 1;
 const KNOWN_TYPES = new Set([
     'string', 'integer', 'number', 'boolean', 'uuid', 'date', 'datetime', 'timestamp',
@@ -847,18 +848,25 @@ function buildDataComparisonSummary(before, after, options) {
 export function runDataVerification(input, options = {}) {
     const validation = validateDataModel(input);
     if (!validation.ok) {
+        const findings = validation.errors.map((message) => ({ code: 'DATA_MODEL_INVALID', severity: 'error', message }));
+        const modelCheck = {
+            id: 'DATA_MODEL',
+            name: 'Data Model Validation',
+            status: 'fail',
+            detail: 'Data model schema validation failed: ' + validation.errors.length + ' errors',
+            findings,
+        };
         return {
             ok: false,
+            ran: true,
+            ...verdictOfFindings(findings),
+            schema: REPORT_SCHEMAS.datamodel,
             schemaVersion: 1,
             modelHash: '',
+            hashes: { modelHash: '' },
             summary: { entities: 0, fields: 0, errors: validation.errors.length, warnings: 0, checksRun: 0 },
-            checks: [{
-                    id: 'DATA_MODEL',
-                    name: 'Data Model Validation',
-                    status: 'fail',
-                    detail: 'Data model schema validation failed: ' + validation.errors.length + ' errors',
-                    findings: validation.errors.map((message) => ({ code: 'DATA_MODEL_INVALID', severity: 'error', message })),
-                }],
+            checks: [modelCheck],
+            nextSteps: dataNextSteps([modelCheck]),
         };
     }
     const model = validation.model;
@@ -884,10 +892,15 @@ export function runDataVerification(input, options = {}) {
     if (options.beforeModel !== undefined) {
         const beforeValidation = validateDataModel(options.beforeModel);
         if (!beforeValidation.ok) {
+            const beforeFindings = beforeValidation.errors.map((message) => ({ code: 'BEFORE_DATA_MODEL_INVALID', severity: 'error', message }));
             return {
                 ok: false,
+                ran: true,
+                ...verdictOfFindings([...checks.flatMap((check) => check.findings), ...beforeFindings]),
+                schema: REPORT_SCHEMAS.datamodel,
                 schemaVersion: 1,
                 modelHash: dataModelHash(model),
+                hashes: { modelHash: dataModelHash(model) },
                 summary: {
                     entities: model.entities.length,
                     fields: allFieldPaths(model).length,
@@ -902,9 +915,10 @@ export function runDataVerification(input, options = {}) {
                         name: 'Before Data Model Validation',
                         status: 'fail',
                         detail: 'Before data model schema validation failed: ' + beforeValidation.errors.length + ' errors',
-                        findings: beforeValidation.errors.map((message) => ({ code: 'BEFORE_DATA_MODEL_INVALID', severity: 'error', message })),
+                        findings: beforeFindings,
                     },
                 ],
+                nextSteps: dataNextSteps(checks),
             };
         }
         const before = beforeValidation.model;
@@ -915,8 +929,12 @@ export function runDataVerification(input, options = {}) {
     const warnings = checks.reduce((sum, check) => sum + check.findings.filter((finding) => finding.severity === 'warning').length, 0);
     return {
         ok: true,
+        ran: true,
+        ...verdictOfFindings(checks.flatMap((check) => check.findings)),
+        schema: REPORT_SCHEMAS.datamodel,
         schemaVersion: 1,
         modelHash: dataModelHash(model),
+        hashes: { modelHash: dataModelHash(model) },
         summary: {
             entities: model.entities.length,
             fields: allFieldPaths(model).length,
@@ -925,6 +943,22 @@ export function runDataVerification(input, options = {}) {
             checksRun: checks.length,
         },
         checks,
+        nextSteps: dataNextSteps(checks),
         ...(comparison === undefined ? {} : { comparison }),
     };
 }
+/**
+ * The next-steps list every data report carries, derived only from the checks so two
+ * runs over the same model produce the same list.
+ */
+function dataNextSteps(checks) {
+    const steps = [];
+    const failed = checks.filter((check) => check.status === 'fail').map((check) => check.id + ' ' + check.name);
+    const warningCodes = [...new Set(checks.flatMap((check) => check.findings).filter((finding) => finding.severity === 'warning').map((finding) => finding.code))].sort();
+    if (failed.length > 0)
+        steps.push('Resolve the failing checks first: ' + failed.join(', ') + '.');
+    if (warningCodes.length > 0)
+        steps.push('Review the warning findings (' + warningCodes.join(', ') + '): a nullable field or a missing index is a decision, not silence.');
+    steps.push('Re-run with beforeModel plus the mapping/copy/migration options after the change to prove the data behaviour did not regress (DD1-DD4).');
+    return steps;
+}