@sungen/driver-data-factory 3.2.10-beta.6 → 3.2.12-beta.10

package/src/validate.ts

@@ -0,0 +1,77 @@
+/**
+ * Data Factory — the deterministic data-quality validator (the Driver's contribution to the harness).
+ *
+ * `lint.ts` answers "is the coverage enough?" (≥1 valid, boundary present, error codes mapped).
+ * This module answers the harder question both reviews flagged: "is each generated value SEMANTICALLY
+ * correct?" — i.e. does a value labeled `valid` actually satisfy the constraints, and does a value
+ * labeled `invalid` actually violate them? It is the machine oracle a future Master "Data Gate"
+ * (see docs/spec/data-factory-quality-roadmap.md) calls; today it powers the golden tests and the
+ * `sungen data validate` CLI. Pure + deterministic — no AI, no runtime.
+ */
+import type { Catalog, SelectionContext } from './types';
+import { expandFieldMap, type FieldMap, type FieldDef, type ExpandedField, type ExpandedPoint } from './generator';
+import { satisfiesConstraints } from './boundary';
+
+export interface ValidationFinding {
+  field: string;
+  pointId: string;
+  severity: 'error' | 'warn';
+  code: 'VALUE_NOT_VALID' | 'INVALID_LOOKS_VALID';
+  message: string;
+}
+
+/** Validate the values a set of expanded points, given the effective constraints for that field. */
+export function validatePoints(field: string, type: string | undefined, points: ExpandedPoint[], c: Record<string, any>): ValidationFinding[] {
+  const out: ValidationFinding[] = [];
+  if (!type) return out;
+  for (const p of points) {
+    if (p.value == null) continue; // open/todo — lint handles these
+    const oracle = satisfiesConstraints(type, p.value, c);
+    if (oracle == null) continue; // no length/range constraint to judge against
+    if (p.expectedValidity === 'valid' && oracle === false) {
+      out.push({
+        field, pointId: p.id, severity: 'error', code: 'VALUE_NOT_VALID',
+        message: `${p.id}: value ${JSON.stringify(p.value)} is expected VALID but violates the field constraints (${describe(type, c)})`,
+      });
+    } else if (p.expectedValidity === 'invalid' && oracle === true && p.synthesized) {
+      // Only second-guess a SYNTHESIZED (boundary/range) invalid: its whole claim is about range, so
+      // satisfying the range means the boundary was mis-synthesized. Literal charset/format invalids and
+      // security payloads legitimately pass the length oracle — not a finding.
+      out.push({
+        field, pointId: p.id, severity: 'warn', code: 'INVALID_LOOKS_VALID',
+        message: `${p.id}: value ${JSON.stringify(p.value)} is expected INVALID (out of range) but satisfies the constraints (${describe(type, c)}) — the boundary was mis-synthesized`,
+      });
+    }
+  }
+  return out;
+}
+
+function describe(type: string, c: Record<string, any>): string {
+  const parts: string[] = [];
+  if (Number.isFinite(c.minLength ?? c.length)) parts.push(`minLen=${c.minLength ?? c.length}`);
+  if (Number.isFinite(c.maxLength ?? c.length)) parts.push(`maxLen=${c.maxLength ?? c.length}`);
+  if (Number.isFinite(c.min)) parts.push(`min=${c.min}`);
+  if (Number.isFinite(c.max)) parts.push(`max=${c.max}`);
+  if (Number.isFinite(c.maxLocal)) parts.push(`maxLocal=${c.maxLocal}`);
+  if (Number.isFinite(c.maxTotal)) parts.push(`maxTotal=${c.maxTotal}`);
+  if (Number.isFinite(c.decimalPlaces)) parts.push(`decimalPlaces=${c.decimalPlaces}`);
+  return parts.join(', ') || type;
+}
+
+/** Validate a whole field-map: expand it, then check every value against its expected validity. */
+export function validateGenerated(map: FieldMap, catalog: Catalog, ctx: SelectionContext = {}): ValidationFinding[] {
+  const expanded = expandFieldMap(map, catalog, ctx);
+  const out: ValidationFinding[] = [];
+  const walk = (efs: ExpandedField[], defs: FieldDef[], prefix: string) => {
+    for (const ef of efs) {
+      const def = defs.find((d) => d.name === ef.name);
+      const path = prefix ? `${prefix}.${ef.name}` : ef.name;
+      if (ef.children) { walk(ef.children, def?.fields || [], path); continue; }
+      const ft = ef.type ? catalog.fieldTypes[ef.type] : undefined;
+      const c = { ...(ft?.constraints || {}), ...(def?.constraints || {}) };
+      out.push(...validatePoints(path, ef.type, ef.points, c));
+    }
+  };
+  walk(expanded, map.fields, '');
+  return out;
+}