@sungen/driver-db 3.2.10 → 3.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-db",
-  "version": "3.2.10",
+  "version": "3.2.11",
   "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",
@@ -10,7 +10,11 @@
       "pg": "^8",
       "mysql2": "^3",
       "better-sqlite3": "^11",
-      "ssh2": "^1"
+      "ssh2": "^1",
+      "@azure/cosmos": "^4",
+      "mongodb": "^7",
+      "@aws-sdk/client-dynamodb": "^3",
+      "@aws-sdk/lib-dynamodb": "^3"
     }
   },
   "scripts": {
@@ -19,7 +23,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.10"
+    "@sun-asterisk/sungen": "3.2.11"
   },
   "files": [
     "dist",

package/src/index.ts

@@ -16,7 +16,7 @@
  * core-resident catalog), so this driver registers no gate sensor.
  */
 import type { CapabilityRegistry } from '@sun-asterisk/sungen';
-import { parseQueryOverrides, resolveQuery, compileQuery } from '@sun-asterisk/sungen';
+import { parseQueryOverrides, resolveQuery, compileQuery, compileShape, isShapeEntry } from '@sun-asterisk/sungen';
 import { databasePatterns, isDbStep } from './patterns/database-patterns';
 
 /**
@@ -32,13 +32,27 @@ function dbPreconditionCodegen(input: { tags: string[]; screenName: string; cwd:
     const name = m[1];
     const overrides = parseQueryOverrides(m[2]);
     const entry = resolveQuery(name, input.screenName, input.cwd); // throws (fail-fast) if missing/ambiguous
-    const { sql, paramNames } = compileQuery(entry);
-    const paramExprs = paramNames.map((p) => (p in overrides ? overrides[p] : `testData.get(${JSON.stringify(p)})`));
     const label = JSON.stringify(entry.description ? `query "${name}" — ${entry.description}` : `query "${name}"`);
     const ds = entry.datasource ? JSON.stringify(entry.datasource) : 'undefined';
+    // Bind params with raw() (uncoerced native type), not get() (Gherkin-text stringify) — numeric
+    // filters must reach the DB as numbers (MySQL `LIMIT '30'` is a syntax error; a type-strict store
+    // never matches a stringified number).
+    const bind = (p: string): string => (p in overrides ? overrides[p] : `testData.raw(${JSON.stringify(p)})`);
+    let code: string;
+    if (isShapeEntry(entry)) {
+      // MongoDB find/pipeline: emit the shape as-authored + a named param map; the engine substitutes
+      // `:param` placeholders at runtime (type-preserving) and runs the operator blocklist.
+      const { shape, paramNames } = compileShape(entry);
+      const paramMap = paramNames.map((p) => `${JSON.stringify(p)}: ${bind(p)}`);
+      code = `testData.bind(${JSON.stringify(name)}, await db.fetchQueryShape(${label}, ${JSON.stringify(shape)}, { ${paramMap.join(', ')} }, ${ds}));`;
+    } else {
+      const { sql, paramNames } = compileQuery(entry);
+      const paramExprs = paramNames.map(bind);
+      code = `testData.bind(${JSON.stringify(name)}, await db.fetchQuery(${label}, ${JSON.stringify(sql)}, [${paramExprs.join(', ')}], ${ds}));`;
+    }
     out.push({
       comment: `@query:${name} → bind {{${name}}} from ${entry.datasource || 'default datasource'}`,
-      code: `testData.bind(${JSON.stringify(name)}, await db.fetchQuery(${label}, ${JSON.stringify(sql)}, [${paramExprs.join(', ')}], ${ds}));`,
+      code,
       boundVars: [name],
     });
   }

package/src/patterns/database-patterns.ts

@@ -31,7 +31,9 @@ export function isDbStep(text: string): boolean {
 function valueExpr(token: string): string {
   const t = token.trim();
   const v = t.match(/^\{\{\s*([^}]+?)\s*\}\}$/);
-  if (v) return `testData.get(${JSON.stringify(v[1])})`;
+  // raw() keeps the native type so numeric filters bind as numbers (a type-strict store won't
+  // match a stringified number); the expected-column compare stringifies both sides anyway.
+  if (v) return `testData.raw(${JSON.stringify(v[1])})`;
   const q = t.match(/^["'](.*)["']$/);
   if (q) return JSON.stringify(q[1]);
   if (/^-?\d+(?:\.\d+)?$/.test(t)) return t;