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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-data-factory",
-  "version": "3.2.12-beta.5",
+  "version": "3.2.12-beta.6",
   "description": "Sungen Data Factory capability — standardized test-data generation from a field-type + security knowledge catalog (valid/boundary/invalid + traceability), the .overwrite merge layer, and (opt-in) @dataFactory runtime seeding. Design-time knowledge is runtime-free. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -14,7 +14,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.12-beta.5",
+    "@sun-asterisk/sungen": "3.2.12-beta.6",
     "yaml": "^2.4.0"
   },
   "files": [

package/src/cli.ts

@@ -233,7 +233,7 @@ export function registerDataFactoryCommand(program: any): void {
     .description('Generate a CSV import fixture from the field-map (bulk-import / file-upload testing)')
     .requiredOption('--screen <name>', 'Unit whose field-map to build a fixture from')
     .option('--rows <n>', 'Number of valid rows', '3')
-    .option('--invalid', 'Also write <name>.invalid.csv (one seeded-bad row per field + _violation column)')
+    .option('--invalid', 'Also write <name>.invalid.csv (one seeded-bad row per field) + <name>.invalid.expected.yaml (per-row expected rejection)')
     .option('--force', 'Overwrite existing fixture file(s) without asking')
     .action(async (opts: { screen: string; rows?: string; invalid?: boolean; force?: boolean }) => {
       const cwd = process.cwd();
@@ -247,12 +247,18 @@ export function registerDataFactoryCommand(program: any): void {
       const validPath = join(dir, `${opts.screen}.csv`);
       const writes: Array<[string, string]> = [[validPath, res.valid]];
       if (res.invalid) writes.push([join(dir, `${opts.screen}.invalid.csv`), res.invalid]);
+      // Sidecar: expected rejection per row — keeps the CSV payload clean (no _violation column).
+      if (res.expected) writes.push([join(dir, `${opts.screen}.invalid.expected.yaml`), stringifyYaml(res.expected)]);
       for (const [p] of writes) {
         if (existsSync(p) && !opts.force) {
           const a = (await ask(`  ? ${p.replace(cwd + '/', '')} exists — overwrite? [y/N] `)).toLowerCase();
           if (a !== 'y' && a !== 'yes') { console.log('  · skipped'); return; }
         }
       }
-      for (const [p, content] of writes) { writeFileSync(p, content, 'utf8'); console.log(`  ✓ wrote ${p.replace(cwd + '/', '')} (${res.headers.length} columns)`); }
+      for (const [p, content] of writes) {
+        writeFileSync(p, content, 'utf8');
+        const label = p.endsWith('.expected.yaml') ? 'expected-rejection sidecar' : `${res.headers.length} columns`;
+        console.log(`  ✓ wrote ${p.replace(cwd + '/', '')} (${label})`);
+      }
     });
 }

package/src/fixture.ts

@@ -6,9 +6,11 @@
  * Export` checklist area. Two products:
  *   • the VALID fixture  — N rows of valid values (should import cleanly). Unique fields get a
  *     per-row suffix so rows don't collide.
- *   • the INVALID fixture — one row per field's first invalid case (all-valid except that one field),
- *     plus a trailing `_violation` column naming the field + reason + expected error — so a row-level
- *     import-rejection test knows which row should fail and why.
+ *   • the INVALID fixture — one row per field's first invalid case (all-valid except that one field).
+ *     It carries the SAME headers as the valid file (no extra column) so a schema-strict importer
+ *     fails on the DATA, not on an unexpected column. The "which row is bad and why" lives in a
+ *     SIDECAR (`<name>.invalid.expected.yaml`), keyed by 0-based data-row index — the expected result
+ *     never alters the payload under test.
  *
  * Deterministic: same field-map + catalog → same CSV. Columns are the flattened leaf paths (nested
  * groups → dotted headers, e.g. `address.city`). Reference the file from an `@api` upload (`files:`)
@@ -31,7 +33,11 @@ function leaves(expanded: ExpandedField[], prefix = ''): Leaf[] {
 }
 
 const validOf = (f: ExpandedField): string => f.points.find((p) => p.group === 'valid' && p.value != null)?.value ?? '';
-const firstInvalid = (f: ExpandedField) => f.points.find((p) => p.group === 'invalid' && p.value != null);
+// First concrete invalid, preferring a plain (non-adversarial) format/boundary invalid over a
+// security payload — a bulk-import row-rejection test wants a data violation, not an injection string.
+const firstInvalid = (f: ExpandedField) =>
+  f.points.find((p) => p.group === 'invalid' && p.category !== 'adversarial' && p.value != null) ??
+  f.points.find((p) => p.group === 'invalid' && p.value != null);
 
 /** RFC-4180-ish CSV cell quoting. */
 function cell(v: string): string {
@@ -41,9 +47,23 @@ function row(cells: string[]): string {
   return cells.map(cell).join(',');
 }
 
+/** One expected-rejection entry in the sidecar, keyed to a 0-based data row of the invalid CSV. */
+export interface ExpectedRow {
+  row: number;
+  field: string;
+  chk: string;
+  reason: string;
+  expected_error?: string;
+}
+export interface FixtureExpected {
+  _note: string;
+  rows: ExpectedRow[];
+}
+
 export interface FixtureResult {
   valid: string;               // CSV text (header + N valid rows)
-  invalid?: string;            // CSV text (header + _violation + one bad row per field)
+  invalid?: string;            // CSV text (SAME headers as valid + one bad row per field — no extra column)
+  expected?: FixtureExpected;  // sidecar: per-row expected rejection (0-based data-row index)
   headers: string[];
 }
 
@@ -62,18 +82,30 @@ export function generateFixture(map: FieldMap, catalog: Catalog, opts: { rows?:
   const valid = [row(headers), ...validRows].join('\n') + '\n';
 
   let invalid: string | undefined;
+  let expected: FixtureExpected | undefined;
   if (opts.includeInvalid) {
-    const invHeaders = [...headers, '_violation'];
     const invRows: string[] = [];
+    const expectedRows: ExpectedRow[] = [];
     for (const target of ls) {
       const bad = firstInvalid(target.field);
       if (!bad) continue; // no concrete invalid value to seed
+      // Same columns as the valid file — only the target cell is bad. No `_violation` column: a
+      // schema-strict importer must fail on the data, not reject the file for an unexpected column.
       const cells = ls.map((l) => (l === target ? (bad.value as string) : validOf(l.field).replace(/\{\{\$timestamp\}\}/g, '1')));
-      const why = `${target.path}: ${bad.reason || 'invalid'}${bad.expectedError ? ` (${bad.expectedError})` : ''}`;
-      invRows.push(row([...cells, why]));
+      expectedRows.push(trimExpected({ row: invRows.length, field: target.path, chk: bad.id, reason: bad.reason || 'invalid', expected_error: bad.expectedError }));
+      invRows.push(row(cells));
     }
-    invalid = [row(invHeaders), ...invRows].join('\n') + '\n';
+    invalid = [row(headers), ...invRows].join('\n') + '\n';
+    expected = {
+      _note: 'Each row of the .invalid.csv should be REJECTED. `row` is the 0-based data-row index (header excluded). The CSV carries no extra columns so a strict importer fails on the data, not the schema.',
+      rows: expectedRows,
+    };
   }
 
-  return { valid, invalid, headers };
+  return { valid, invalid, expected, headers };
+}
+
+function trimExpected(e: ExpectedRow): ExpectedRow {
+  if (e.expected_error == null) { const { expected_error, ...rest } = e; return rest as ExpectedRow; }
+  return e;
 }

package/src/index.ts

@@ -30,7 +30,7 @@ export type { Validity, BoundaryPoint } from './boundary';
 export { evaluateWhen, inProfile, fieldFacts } from './applicability';
 export { registerDataFactoryCommand } from './cli';
 export { generateFixture } from './fixture';
-export type { FixtureResult } from './fixture';
+export type { FixtureResult, FixtureExpected, ExpectedRow } from './fixture';
 export { dataFactoryCoverageSensor } from './sensor';
 export { dfPreconditionCodegen } from './precondition';
 export type { Catalog, FieldType, SecurityBank, Technique, DataPoint, OverwriteWarning, CatalogProvenance, FieldTypeProvenance, SelectionContext, Profile } from './types';