fix: queryToSql now emits DISTINCT and COUNT(DISTINCT col) for WASM SQL

queryToSql silently dropped the DISTINCT keyword, causing WASM to
return all rows for DISTINCT queries (TS DistinctOperator caught it,
but at the cost of transferring extra data). Also fixed count_distinct
generating invalid COUNT_DISTINCT() instead of COUNT(DISTINCT col).

Author: teamchong

src/wasm-engine.integration.test.ts

@@ -4,7 +4,7 @@
  * Skips gracefully if binary not found.
  */
 import { describe, it, expect, beforeAll } from "vitest";
-import { instantiateWasm, type WasmEngine } from "./wasm-engine.js";
+import { instantiateWasm, queryToSql, type WasmEngine } from "./wasm-engine.js";
 import type { QueryDescriptor } from "./client.js";
 import type { PageInfo } from "./types.js";
 import * as fs from "node:fs/promises";
@@ -343,3 +343,49 @@ describe.skipIf(!hasWasm)("WASM integration", () => {
     });
   });
 });
+
+// Pure-TS tests — no WASM binary required
+describe("queryToSql", () => {
+  const base = { table: "t", filters: [] as any[], projections: [] as string[] };
+
+  it("generates SELECT DISTINCT", () => {
+    const sql = queryToSql({ ...base, distinct: ["a", "b"] });
+    expect(sql).toBe('SELECT DISTINCT * FROM t');
+  });
+
+  it("generates SELECT DISTINCT with projections", () => {
+    const sql = queryToSql({ ...base, distinct: ["a"], projections: ["a", "b"] });
+    expect(sql).toBe('SELECT DISTINCT a, b FROM t');
+  });
+
+  it("generates COUNT(DISTINCT col) for count_distinct", () => {
+    const sql = queryToSql({ ...base, aggregates: [{ fn: "count_distinct", column: "user_id" }] });
+    expect(sql).toContain("COUNT(DISTINCT user_id)");
+  });
+
+  it("generates COUNT(*) for count with star", () => {
+    const sql = queryToSql({ ...base, aggregates: [{ fn: "count", column: "*" }] });
+    expect(sql).toContain("COUNT(*)");
+  });
+
+  it("includes OR filterGroups", () => {
+    const sql = queryToSql({
+      ...base,
+      filterGroups: [
+        [{ column: "a", op: "eq", value: 1 }],
+        [{ column: "b", op: "eq", value: 2 }],
+      ],
+    });
+    expect(sql).toContain("(a = 1 OR b = 2)");
+  });
+
+  it("handles NOT IN filter", () => {
+    const sql = queryToSql({ ...base, filters: [{ column: "id", op: "not_in", value: [1, 2] }] });
+    expect(sql).toContain("NOT IN (1, 2)");
+  });
+
+  it("handles NOT BETWEEN filter", () => {
+    const sql = queryToSql({ ...base, filters: [{ column: "x", op: "not_between", value: [10, 20] }] });
+    expect(sql).toContain("NOT BETWEEN 10 AND 20");
+  });
+});

src/wasm-engine.ts

@@ -1027,21 +1027,28 @@ function filterToSql(f: FilterOp): string {
   return `${quote(f.column)} ${COMPARISON_OP_MAP[f.op] ?? "="} ${val}`;
 }
 
-function queryToSql(query: QueryDescriptor): string {
+/** @internal — exported for testing */
+export function queryToSql(query: QueryDescriptor): string {
   const parts: string[] = [];
 
+  const distinctKw = query.distinct?.length ? "DISTINCT " : "";
   if (query.aggregates?.length) {
     const exprs: string[] = [];
     if (query.groupBy) exprs.push(...query.groupBy.map(quote));
     for (const agg of query.aggregates) {
-      const expr = `${agg.fn.toUpperCase()}(${agg.column === "*" ? "*" : quote(agg.column)})`;
+      let expr: string;
+      if (agg.fn === "count_distinct") {
+        expr = `COUNT(DISTINCT ${agg.column === "*" ? "*" : quote(agg.column)})`;
+      } else {
+        expr = `${agg.fn.toUpperCase()}(${agg.column === "*" ? "*" : quote(agg.column)})`;
+      }
       exprs.push(agg.alias ? `${expr} AS ${quote(agg.alias)}` : expr);
     }
-    parts.push(`SELECT ${exprs.join(", ")}`);
+    parts.push(`SELECT ${distinctKw}${exprs.join(", ")}`);
   } else if (query.projections.length > 0) {
-    parts.push(`SELECT ${query.projections.map(quote).join(", ")}`);
+    parts.push(`SELECT ${distinctKw}${query.projections.map(quote).join(", ")}`);
   } else {
-    parts.push("SELECT *");
+    parts.push(`SELECT ${distinctKw}*`);
   }
 
   parts.push(`FROM ${quote(query.table)}`);