Fix sql-compiler to handle empty strings like eq(column, '') (#1146)

* Fix empty string being incorrectly treated as NULL in queries

The sql-compiler was filtering out empty strings from query params,
treating them the same as null/undefined values. This caused queries
like `eq(column, '')` to incorrectly generate `WHERE column = NULL`
instead of `WHERE column = ''`.

The fix changes the filter condition to check the original value for
null/undefined instead of checking if the serialized value is an
empty string. This allows legitimate empty string queries to work
correctly while still properly omitting null/undefined params.

* ci: apply automated fixes

* Simplify null/undefined check to idiomatic pattern

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Add regression tests for issue #1147

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Add like/ilike empty string tests for defense-in-depth

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Remove duplicate empty string test

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Add changeset for empty string fix

Co-Authored-By: Claude Opus 4.5 <[email protected]>

---------

Co-authored-by: Claude <[email protected]>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: 3 people

.changeset/fix-empty-string-params.md

@@ -0,0 +1,5 @@
+---
+'@tanstack/electric-db-collection': patch
+---
+
+Fix empty string values being incorrectly omitted from SQL query params. Queries like `eq(column, '')` now correctly include the empty string parameter instead of producing a malformed query with a missing `$1` value.

packages/electric-db-collection/src/sql-compiler.ts

@@ -38,9 +38,9 @@ export function compileSQL<T>(options: LoadSubsetOptions): SubsetParams {
   const paramsRecord = params.reduce(
     (acc, param, index) => {
       const serialized = serialize(param)
-      // Only include non-empty values in params
-      // Empty strings from null/undefined should be omitted
-      if (serialized !== ``) {
+      // Empty strings are valid query values (e.g., WHERE column = '')
+      // Only omit null/undefined values from params
+      if (param != null) {
         acc[`${index + 1}`] = serialized
       }
       return acc

packages/electric-db-collection/tests/sql-compiler.test.ts

@@ -68,6 +68,54 @@ describe(`sql-compiler`, () => {
         expect(result.where).toBe(`"rating" <= $1`)
         expect(result.params).toEqual({ '1': `5` })
       })
+
+      // Regression test for https://github.com/TanStack/db/issues/1147
+      it(`should compile eq with empty string value`, () => {
+        const result = compileSQL({
+          where: func(`eq`, [ref(`status`), val(``)]),
+        })
+        expect(result.where).toBe(`"status" = $1`)
+        expect(result.params).toEqual({ '1': `` })
+      })
+
+      it(`should compile eq with empty string in AND clause`, () => {
+        const result = compileSQL({
+          where: func(`and`, [
+            func(`eq`, [ref(`projectId`), val(`uuid-123`)]),
+            func(`eq`, [ref(`status`), val(``)]),
+          ]),
+        })
+        expect(result.where).toBe(`"projectId" = $1 AND "status" = $2`)
+        expect(result.params).toEqual({ '1': `uuid-123`, '2': `` })
+      })
+
+      it(`should handle multiple empty strings with correct param indices`, () => {
+        const result = compileSQL({
+          where: func(`and`, [
+            func(`eq`, [ref(`field1`), val(``)]),
+            func(`eq`, [ref(`field2`), val(``)]),
+          ]),
+        })
+        expect(result.where).toBe(`"field1" = $1 AND "field2" = $2`)
+        // Both empty strings should be present with correct indices
+        expect(result.params).toEqual({ '1': ``, '2': `` })
+      })
+
+      it(`should compile like with empty string pattern`, () => {
+        const result = compileSQL({
+          where: func(`like`, [ref(`description`), val(``)]),
+        })
+        expect(result.where).toBe(`"description" LIKE $1`)
+        expect(result.params).toEqual({ '1': `` })
+      })
+
+      it(`should compile ilike with empty string pattern`, () => {
+        const result = compileSQL({
+          where: func(`ilike`, [ref(`title`), val(``)]),
+        })
+        expect(result.where).toBe(`"title" ILIKE $1`)
+        expect(result.params).toEqual({ '1': `` })
+      })
     })
 
     describe(`compound where clauses`, () => {

packages/vue-db/tests/useLiveQuery.test-d.ts

@@ -132,6 +132,8 @@ describe(`useLiveQuery type assertions`, () => {
     )
 
     // Regular queries should return an array
-    expectTypeOf(data.value).toEqualTypeOf<Array<{ id: string; name: string }>>()
+    expectTypeOf(data.value).toEqualTypeOf<
+      Array<{ id: string; name: string }>
+    >()
   })
 })