@sun-asterisk/sungen 3.2.10 → 3.2.12-beta.1

package/src/orchestrator/templates/specs-test-data.ts

@@ -48,9 +48,27 @@ export class TestDataLoader {
     if (value === undefined || value === null) {
       throw new Error(`Test data key not found: ${key}`);
     }
+    // A projected array (e.g. `{{q.rows[*].name}}`) serializes as a JSON list so the full
+    // ordered set is preserved for the assert-compare — String([...]) would flatten it to a
+    // lossy comma-join that can't be distinguished from a scalar containing commas.
+    if (Array.isArray(value)) return this.interpolate(JSON.stringify(value));
     return this.interpolate(String(value));
   }
 
+  /**
+   * Resolve a key to its RAW, uncoerced value (array/object/number kept as-is) — for binding
+   * DB query parameters, where type-strict stores (MySQL numeric columns, MongoDB) require the
+   * native type. get() stringifies for Gherkin text; raw() must not. Throws on missing, mirroring
+   * get()'s guard.
+   */
+  raw(key: string): any {
+    const value = this.resolve(key);
+    if (value === undefined || value === null) {
+      throw new Error(`Test data key not found: ${key}`);
+    }
+    return value;
+  }
+
   /**
    * Substitute embedded `{{ref}}` cross-references inside a resolved string value.
    * Each ref is looked up via resolve() (flat key, @cases row column, or dotted path),
@@ -78,6 +96,7 @@ export class TestDataLoader {
    *      `q.count` / `q.length`  → number of rows
    *      `q.first.col` / `q.last.col` / `q[2].col` → a specific row's column
    *      `q.col`                → shorthand for the first row's column
+   *      `q.rows[*].col`        → the `col` of EVERY row, projected to an ordered array
    */
   private resolve(key: string): any {
     // 1. Exact flat key — captured vars (set()) live under a literal, possibly dotted, key.
@@ -88,9 +107,26 @@ export class TestDataLoader {
       return this.data[key];
     }
     // 2. Structured path: head from the row (cases) or shared data, then walk segments.
-    const tokens = String(key).replace(/\[(\d+)\]/g, '.$1').split('.');
-    let cur: any = (this.row && tokens[0] in this.row) ? this.row[tokens[0]] : this.data[tokens[0]];
-    for (let i = 1; i < tokens.length && cur != null; i++) cur = TestDataLoader.step(cur, tokens[i]);
+    //    `[n]` → `.n` (numeric index); `[*]` → `.*` (project the rest of the path over each element).
+    const tokens = String(key).replace(/\[(\d+)\]/g, '.$1').replace(/\[\*\]/g, '.*').split('.');
+    const cur: any = (this.row && tokens[0] in this.row) ? this.row[tokens[0]] : this.data[tokens[0]];
+    return TestDataLoader.walk(cur, tokens, 1);
+  }
+
+  /**
+   * Walk the remaining path tokens from `i`. A `*` token on an array projects: the rest of the
+   * path is mapped over every element and the collected array returned (recurses for nested `[*]`).
+   * Non-`*` tokens use the linear single-step navigation, so numeric/first/last/object access is
+   * unchanged.
+   */
+  private static walk(cur: any, tokens: string[], i: number): any {
+    for (; i < tokens.length && cur != null; i++) {
+      if (tokens[i] === '*' && Array.isArray(cur)) {
+        const rest = tokens.slice(i + 1);
+        return cur.map((el) => TestDataLoader.walk(el, rest, 0));
+      }
+      cur = TestDataLoader.step(cur, tokens[i]);
+    }
     return cur;
   }