@sungen/driver-data-factory 3.2.32 → 3.2.34-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-data-factory",
-  "version": "3.2.32",
+  "version": "3.2.34-beta.1",
   "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.32",
+    "@sun-asterisk/sungen": "3.2.34-beta.1",
     "yaml": "^2.4.0"
   },
   "files": [

package/src/cli.ts

@@ -6,7 +6,7 @@
  * then generate the standardized `test-data/<name>.yaml` or lint its coverage. The slash command
  * `/sungen:create-data-test` wraps these after the AI has authored the field-map from spec.md.
  */
-import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, renameSync, rmSync } from 'fs';
 import { join, dirname } from 'path';
 import { createInterface } from 'readline';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
@@ -69,7 +69,23 @@ function loadFieldMap(cwd: string, name: string): FieldMap | null {
   return parseYaml(readFileSync(p, 'utf8')) as FieldMap;
 }
 
-async function genOne(cwd: string, name: string, opts: { force?: boolean; ctx?: SelectionContext }): Promise<'written' | 'skipped' | 'missing'> {
+/**
+ * Write via a sibling tmp + rename, so an interrupted run can never leave a truncated test-data
+ * file. Local rather than core's `writeFileAtomic`: every import from `@sun-asterisk/sungen` in
+ * this package is `import type`, deliberately, so loading the driver never forces a core resolve.
+ */
+function writeTestDataAtomic(file: string, data: string): void {
+  const tmp = `${file}.tmp-${process.pid}`;
+  try {
+    writeFileSync(tmp, data, 'utf8');
+    renameSync(tmp, file);
+  } catch (err) {
+    try { rmSync(tmp, { force: true }); } catch { /* best-effort cleanup — the real error is below */ }
+    throw err;
+  }
+}
+
+async function genOne(cwd: string, name: string, opts: { force?: boolean; ctx?: SelectionContext }): Promise<'written' | 'skipped' | 'missing' | 'failed'> {
   const map = loadFieldMap(cwd, name);
   if (!map) { console.error(`  ✗ ${name}: no field-map at qa/data-factory/${name}.fields.yaml (author it first, e.g. via /sungen:create-data-test)`); return 'missing'; }
   const { catalog, warnings, provenance } = loadEffectiveCatalog(cwd);
@@ -96,17 +112,34 @@ async function genOne(cwd: string, name: string, opts: { force?: boolean; ctx?:
   let final = dfData;
   let mergedInto = false;
   if (exists) {
+    // Read the existing file BEFORE asking. The prompt promises to keep the other keys; asking for
+    // consent to a merge we have already failed to read is asking the user to approve their own
+    // data loss — and answering "y" to that promise is exactly what used to destroy the file.
+    let existing: Record<string, any>;
+    try {
+      existing = (parseYaml(readFileSync(out, 'utf8')) as Record<string, any>) || {};
+    } catch (e) {
+      // Refuse, the way `delivery.ts` refuses to overwrite a workbook it could not read. Swallowing
+      // this meant `existing = {}`, so the merge wrote ONLY the Data Factory keys over a file of
+      // credentials, URLs and @cases datasets — and then printed "other keys preserved".
+      // `--force` does not change this: it means "do not ask", not "destroy without reading".
+      const rel = out.replace(cwd + '/', '');
+      console.error(`  ✗ ${name}: not written — ${rel} could not be parsed (${(e as Error).message.split('\n')[0]})`);
+      console.error(`      Merging would keep none of its existing keys, so nothing was written.`);
+      console.error(`      Fix the YAML and re-run, or move the file aside to generate a fresh one.`);
+      return 'failed';
+    }
     if (!opts.force) {
       const a = (await ask(`  ? ${name}: test-data exists — merge standardized field data in (keeps other keys)? [y/N] `)).toLowerCase();
       if (a !== 'y' && a !== 'yes') { console.log(`  · ${name}: skipped`); return 'skipped'; }
     }
-    let existing: Record<string, any> = {};
-    try { existing = (parseYaml(readFileSync(out, 'utf8')) as Record<string, any>) || {}; } catch { existing = {}; }
     final = { ...existing, ...dfData }; // DF-owned keys win; all other existing keys preserved
     mergedInto = true;
   }
   mkdirSync(dirname(out), { recursive: true });
-  writeFileSync(out, stringifyYaml(final), 'utf8');
+  // Atomic: this file is user-authored test-data that we have just promised to preserve. A crash
+  // between truncate and write would leave it half-written — the same loss by a different route.
+  writeTestDataAtomic(out, stringifyYaml(final));
   const blind = expanded.filter((f) => f.blindSpot).map((f) => f.name);
   const verb = mergedInto ? 'merged into' : 'wrote';
   const fieldKeys = expanded.map((f) => f.name).length;
@@ -133,7 +166,14 @@ export function registerDataFactoryCommand(program: any): void {
       ensureDataFactoryReadme(cwd);
       let ctx: SelectionContext;
       try { ctx = ctxFromOpts(opts); } catch (e: any) { console.error(e.message); process.exitCode = 1; return; }
-      if (opts.screen) { await genOne(cwd, opts.screen, { ...opts, ctx }); return; }
+      if (opts.screen) {
+        // A run that wrote nothing must not report success to the shell. `skipped` is the user's own
+        // answer to the prompt, so it stays 0; `failed` (unreadable target) and `missing` (no
+        // field-map) are errors that scripts and CI need to see.
+        const outcome = await genOne(cwd, opts.screen, { ...opts, ctx });
+        if (outcome === 'failed' || outcome === 'missing') process.exitCode = 1;
+        return;
+      }
       if (!opts.all) {
         console.error('Specify --screen <name> for one unit, or --all for every unit (with confirmation).');
         process.exitCode = 1;
@@ -150,8 +190,16 @@ export function registerDataFactoryCommand(program: any): void {
         if (a !== 'y' && a !== 'yes') { console.log('Cancelled.'); return; }
       }
       let written = 0;
-      for (const n of names) if ((await genOne(cwd, n, { force: opts.force, ctx })) === 'written') written++;
-      console.log(`Done: ${written}/${names.length} written.`);
+      let failed = 0;
+      for (const n of names) {
+        const outcome = await genOne(cwd, n, { force: opts.force, ctx });
+        if (outcome === 'written') written++;
+        else if (outcome === 'failed' || outcome === 'missing') failed++;
+      }
+      console.log(`Done: ${written}/${names.length} written${failed ? ` · ${failed} failed` : ''}.`);
+      // One refused unit must not be buried by N successful ones — `--all` over a repo where a
+      // single test-data file is unparseable would otherwise exit 0.
+      if (failed) process.exitCode = 1;
     });
 
   data

package/src/crosscheck.ts

@@ -25,15 +25,42 @@ export interface CrossFinding {
   message: string;
 }
 
-/** Resolve a unit's feature dir + test-data path (screen or flow). */
-function unitPaths(cwd: string, name: string): { featureDir: string; testData: string } | null {
+/** Resolve a unit's feature dir + test-data dir and the unit-named data file (screen or flow). */
+function unitPaths(cwd: string, name: string): { featureDir: string; testData: string; testDataDir: string } | null {
   for (const kind of ['screens', 'flows']) {
     const base = join(cwd, 'qa', kind, name);
-    if (existsSync(base)) return { featureDir: join(base, 'features'), testData: join(base, 'test-data', `${name}.yaml`) };
+    if (existsSync(base)) {
+      return {
+        featureDir: join(base, 'features'),
+        testDataDir: join(base, 'test-data'),
+        testData: join(base, 'test-data', `${name}.yaml`),
+      };
+    }
   }
   return null;
 }
 
+/**
+ * Each `.feature` in the unit paired with the test-data file the COMPILER resolves its `{{vars}}`
+ * against — `<feature>.yaml`, named after the feature, not after the unit.
+ *
+ * This gate used to concatenate every feature in the directory and check the lot against the single
+ * unit-named file, so it disagreed with the loader in both directions: a key living only in
+ * `<feature>.yaml` was reported DANGLING_VAR though it resolved fine, and a feature with no data
+ * file of its own was reported CLEAN while every one of its variables was about to be emitted as a
+ * literal (#781). The second is the one that matters — the gate whose whole job is catching a
+ * dangling `{{var}}` returned `0 error · 0 warn` on exactly the file that had them.
+ */
+function featureDataPairs(featureDir: string, testDataDir: string): Array<{ file: string; text: string; dataFile: string; dataName: string }> {
+  if (!existsSync(featureDir)) return [];
+  return readdirSync(featureDir)
+    .filter((f) => f.endsWith('.feature'))
+    .map((f) => {
+      const dataName = `${f.replace(/\.feature$/, '')}.yaml`;
+      return { file: f, text: readFileSync(join(featureDir, f), 'utf8'), dataFile: join(testDataDir, dataName), dataName };
+    });
+}
+
 function readFeatureText(featureDir: string): string {
   if (!existsSync(featureDir)) return '';
   return readdirSync(featureDir)
@@ -114,16 +141,25 @@ export function crosscheckUnit(cwd: string, name: string): CrossFinding[] {
   if (!paths) return out;
   const feature = readFeatureText(paths.featureDir);
   if (!feature) return out;
-  const data = loadYaml(paths.testData);
-  const topKeys = new Set(Object.keys(data).filter((k) => !k.startsWith('_')));
-  const caseCols = casesColumns(feature, data); // @cases row columns resolve per-row, not as top-level keys
-  const captured = rememberedVars(feature);     // runtime-bound vars — no static key can exist
-
   // 1. Dangling vars — a {{var}} whose root key is absent from test-data (and not a @cases column
-  //    or a runtime-captured binding).
-  for (const v of referencedVars(feature)) {
-    if (!topKeys.has(v) && !caseCols.has(v) && !captured.has(v)) {
-      out.push({ unit: name, severity: 'error', code: 'DANGLING_VAR', message: `scenario references {{${v}}} but no "${v}" key exists in test-data/${name}.yaml` });
+  //    or a runtime-captured binding). Checked PER FEATURE against the file the loader reads for
+  //    that feature, so this gate and the compiler cannot disagree about which file is authoritative.
+  for (const fx of featureDataPairs(paths.featureDir, paths.testDataDir)) {
+    const data = loadYaml(fx.dataFile);
+    const topKeys = new Set(Object.keys(data).filter((k) => !k.startsWith('_')));
+    const caseCols = casesColumns(fx.text, data); // @cases row columns resolve per-row, not as top-level keys
+    const captured = rememberedVars(fx.text);     // runtime-bound vars — no static key can exist
+    for (const v of referencedVars(fx.text)) {
+      if (!topKeys.has(v) && !caseCols.has(v) && !captured.has(v)) {
+        out.push({
+          unit: name,
+          severity: 'error',
+          code: 'DANGLING_VAR',
+          // Names the file actually consulted. The old message always said `<unit>.yaml`, which sent
+          // readers to edit a file the compiler would never read for that feature.
+          message: `${fx.file} references {{${v}}} but no "${v}" key exists in test-data/${fx.dataName}`,
+        });
+      }
     }
   }
 

package/src/sensor.ts

@@ -17,7 +17,7 @@
 import { basename, join } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { parse as parseYaml } from 'yaml';
-import type { Sensor } from '@sun-asterisk/sungen';
+import type { Sensor, SensorFinding } from '@sun-asterisk/sungen';
 import { loadEffectiveCatalog } from './catalog-loader';
 import { lintFieldMap, summarize } from './lint';
 import { validateGenerated } from './validate';
@@ -32,7 +32,7 @@ export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
     const name = basename(dir);
     // Layer A auto-detection — runs regardless of whether a field-map exists, so a unit that needs
     // standardization or a declared precondition is NOTICED, not silently skipped.
-    const detected = detectUnit(cwd, dir, name).map((d) => ({
+    const detected: SensorFinding[] = detectUnit(cwd, dir, name).map((d) => ({
       sensorId: 'data-factory-coverage',
       capability: 'data-factory',
       scenario: d.scenario,
@@ -43,12 +43,31 @@ export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
     const fieldMapPath = join(cwd, 'qa', 'data-factory', `${name}.fields.yaml`);
     if (!existsSync(fieldMapPath)) return detected; // no field-map: report only what detection noticed
     let map: FieldMap;
-    try { map = parseYaml(readFileSync(fieldMapPath, 'utf8')) as FieldMap; } catch { return detected; }
+    try {
+      map = parseYaml(readFileSync(fieldMapPath, 'utf8')) as FieldMap;
+    } catch (e) {
+      // `existsSync` above already answered absence, so this only fires for a field-map that EXISTS
+      // and is broken — and returning `detected` would report it exactly as if none had been
+      // written. That silently drops three families of findings (lintFieldMap issues, the catalog's
+      // OVERWRITE-STALE warnings, validateGenerated), leaving an author who broke their YAML with
+      // the same output as one who never wrote a field map. This sensor has a findings channel;
+      // use it.
+      detected.push({
+        sensorId: 'data-factory-coverage',
+        capability: 'data-factory',
+        scenario: name,
+        message: `DATA-FACTORY-FIELDMAP-UNREADABLE: qa/data-factory/${name}.fields.yaml could not be parsed `
+          + `(${e instanceof Error ? e.message.split('\n')[0] : String(e)}) — coverage lint, stale-catalog `
+          + `warnings and semantic validation are all skipped for this unit until it parses.`,
+        severity: 'error',
+      });
+      return detected;
+    }
     if (!map || !Array.isArray(map.fields)) return detected;
 
     const { catalog, warnings } = loadEffectiveCatalog(cwd);
     const { issues } = lintFieldMap(map, catalog);
-    const findings = issues.map((i) => ({
+    const findings: SensorFinding[] = issues.map((i) => ({
       sensorId: 'data-factory-coverage',
       capability: 'data-factory',
       scenario: i.field,