@sungen/driver-db 3.2.14 → 3.2.16-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-db",
-  "version": "3.2.14",
+  "version": "3.2.16-beta.1",
   "description": "Sungen DB capability (Data Driver) — the @query annotation, query catalog, declarative DB steps, and the specs/db.ts runtime template. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -23,7 +23,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.14"
+    "@sun-asterisk/sungen": "3.2.16-beta.1"
   },
   "files": [
     "dist",

package/src/patterns/database-patterns.ts

@@ -22,11 +22,28 @@ const reNoRow = new RegExp(`see\\s+${TABLE}\\s+no\\s+row\\s+where\\b`, 'i');
 const reCount = new RegExp(`see\\s+${TABLE}.*\\bcount\\s+is\\b`, 'i');
 
 /** True when a step is a declarative DB-verification step (used to wire the `db` import).
- *  Named queries are invoked via the `@query:` annotation, not a step — see code-generator. */
+ *  Named queries are invoked via the `@query:` annotation, not a step — see code-generator.
+ *  Callers pass the ORIGINAL (unmasked) step text here — see the masked matcher pair below. */
 export function isDbStep(text: string): boolean {
   return reNoRow.test(text) || reRow.test(text) || reCount.test(text);
 }
 
+/**
+ * Masked-text matcher pair: PatternRegistry.findPattern() matches against step text with every
+ * `[...]`/`{{...}}` ref CONTENT replaced by `~` (see maskRefsForMatching in core's patterns/index.ts),
+ * so a verb/keyword substring inside a selector or variable name can't hijack classification. The
+ * table identifier here is always a ref, so `[table]` becomes `[~]` at matching time — the RAW
+ * `reRow`/`reNoRow`/`reCount` above can never match masked text. These mirror them against the
+ * masked shape; `isDbStep()` and the generators below still use the raw regexes against the
+ * ORIGINAL step text supplied by the caller.
+ */
+const reRowMasked = /see\s+\[~\]\s+row\s+where\b/i;
+const reNoRowMasked = /see\s+\[~\]\s+no\s+row\s+where\b/i;
+// Mirrors the generator's extraction shape (`[table] [where …] count is`) instead of `.*` — a lax
+// gap would let a UI text assertion whose literal happens to contain "count is" (e.g.
+// `see [Cart badge] contains "count is high"`) claim this priority-60 pattern away from the UI drivers.
+const reCountMasked = /see\s+\[~\](?:\s+where\s+.+?)?\s+count\s+is\b/i;
+
 /** Render a value token (`{{var}}` | "literal" | 'literal' | number) as a JS expression. */
 function valueExpr(token: string): string {
   const t = token.trim();
@@ -62,9 +79,12 @@ export const databasePatterns: StepPattern[] = [
   {
     name: 'db-no-row',
     priority: 60, // above generic see-assertions
-    matcher: (step: ParsedStep) => reNoRow.test(step.text),
+    matcher: (step: ParsedStep) => reNoRowMasked.test(step.text),
     generator: (step: ParsedStep, _ctx: PatternContext): MappedStep => {
-      const m = step.text.match(new RegExp(`${TABLE}\\s+no\\s+row\\s+where\\s+(.+)$`, 'i'))!;
+      // The masked matcher is looser than this extraction regex, so a malformed step (e.g. an
+      // empty table/filter) can claim the pattern yet not re-match here — emit a TODO instead of crashing.
+      const m = step.text.match(new RegExp(`${TABLE}\\s+no\\s+row\\s+where\\s+(.+)$`, 'i'));
+      if (!m) return { code: `// TODO: malformed 'no row' step (expected: User see [table] no row where [col] is VALUE): ${step.text}`, comment: 'Unrecognized db-no-row step' };
       const table = m[1];
       const filter = parseFilter(m[2]);
       return { code: `await db.assertNoRow(${JSON.stringify(table)}, ${filter});`, comment: `DB: no row in ${table}` };
@@ -73,9 +93,10 @@ export const databasePatterns: StepPattern[] = [
   {
     name: 'db-count',
     priority: 60,
-    matcher: (step: ParsedStep) => reCount.test(step.text) && !reRow.test(step.text),
+    matcher: (step: ParsedStep) => reCountMasked.test(step.text) && !reRowMasked.test(step.text),
     generator: (step: ParsedStep, _ctx: PatternContext): MappedStep => {
-      const m = step.text.match(new RegExp(`${TABLE}(?:\\s+where\\s+(.+?))?\\s+count\\s+is\\s+(${VALUE})`, 'i'))!;
+      const m = step.text.match(new RegExp(`${TABLE}(?:\\s+where\\s+(.+?))?\\s+count\\s+is\\s+(${VALUE})`, 'i'));
+      if (!m) return { code: `// TODO: malformed 'count is' step (expected: User see [table] [where [col] is VALUE] count is VALUE): ${step.text}`, comment: 'Unrecognized db-count step' };
       const table = m[1];
       const filter = m[2] ? parseFilter(m[2]) : '{}';
       return { code: `await db.assertCount(${JSON.stringify(table)}, ${filter}, Number(${valueExpr(m[3])}));`, comment: `DB: count rows in ${table}` };
@@ -84,10 +105,11 @@ export const databasePatterns: StepPattern[] = [
   {
     name: 'db-row',
     priority: 60,
-    matcher: (step: ParsedStep) => reRow.test(step.text),
+    matcher: (step: ParsedStep) => reRowMasked.test(step.text),
     generator: (step: ParsedStep, _ctx: PatternContext): MappedStep => {
       // [table] row where <filter> [has <expected>]
-      const m = step.text.match(new RegExp(`${TABLE}\\s+row\\s+where\\s+(.+?)(?:\\s+has\\s+(.+))?$`, 'i'))!;
+      const m = step.text.match(new RegExp(`${TABLE}\\s+row\\s+where\\s+(.+?)(?:\\s+has\\s+(.+))?$`, 'i'));
+      if (!m) return { code: `// TODO: malformed 'row where' step (expected: User see [table] row where [col] is VALUE [has [col2] = VALUE2]): ${step.text}`, comment: 'Unrecognized db-row step' };
       const table = m[1];
       const filter = parseFilter(m[2]);
       const expected = m[3] ? parseExpected(m[3]) : '';