@tanstack/electric-db-collection 0.2.12 → 0.2.13

package/src/electric.ts

@@ -3,17 +3,17 @@ import {
   isChangeMessage,
   isControlMessage,
   isVisibleInSnapshot,
-} from "@electric-sql/client"
-import { Store } from "@tanstack/store"
-import DebugModule from "debug"
-import { DeduplicatedLoadSubset } from "@tanstack/db"
+} from '@electric-sql/client'
+import { Store } from '@tanstack/store'
+import DebugModule from 'debug'
+import { DeduplicatedLoadSubset, and } from '@tanstack/db'
 import {
   ExpectedNumberInAwaitTxIdError,
   StreamAbortedError,
   TimeoutWaitingForMatchError,
   TimeoutWaitingForTxIdError,
-} from "./errors"
-import { compileSQL } from "./sql-compiler"
+} from './errors'
+import { compileSQL } from './sql-compiler'
 import type {
   BaseCollectionConfig,
   CollectionConfig,
@@ -24,8 +24,8 @@ import type {
   SyncMode,
   UpdateMutationFnParams,
   UtilsRecord,
-} from "@tanstack/db"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from '@tanstack/db'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type {
   ControlMessage,
   GetExtensions,
@@ -33,10 +33,10 @@ import type {
   PostgresSnapshot,
   Row,
   ShapeStreamOptions,
-} from "@electric-sql/client"
+} from '@electric-sql/client'
 
 // Re-export for user convenience in custom match functions
-export { isChangeMessage, isControlMessage } from "@electric-sql/client"
+export { isChangeMessage, isControlMessage } from '@electric-sql/client'
 
 const debug = DebugModule.debug(`ts/db:electric`)
 
@@ -66,7 +66,7 @@ export type Txid = number
  * indicating if the mutation has been synchronized
  */
 export type MatchFunction<T extends Row<unknown>> = (
-  message: Message<T>
+  message: Message<T>,
 ) => boolean
 
 /**
@@ -197,7 +197,7 @@ export interface ElectricCollectionConfig<
       T,
       string | number,
       ElectricCollectionUtils<T>
-    >
+    >,
   ) => Promise<MatchingStrategy>
 
   /**
@@ -232,7 +232,7 @@ export interface ElectricCollectionConfig<
       T,
       string | number,
       ElectricCollectionUtils<T>
-    >
+    >,
   ) => Promise<MatchingStrategy>
 
   /**
@@ -266,24 +266,24 @@ export interface ElectricCollectionConfig<
       T,
       string | number,
       ElectricCollectionUtils<T>
-    >
+    >,
   ) => Promise<MatchingStrategy>
 }
 
 function isUpToDateMessage<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is ControlMessage & { up_to_date: true } {
   return isControlMessage(message) && message.headers.control === `up-to-date`
 }
 
 function isMustRefetchMessage<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is ControlMessage & { headers: { control: `must-refetch` } } {
   return isControlMessage(message) && message.headers.control === `must-refetch`
 }
 
 function isSnapshotEndMessage<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is SnapshotEndMessage {
   return isControlMessage(message) && message.headers.control === `snapshot-end`
 }
@@ -298,7 +298,7 @@ function parseSnapshotMessage(message: SnapshotEndMessage): PostgresSnapshot {
 
 // Check if a message contains txids in its headers
 function hasTxids<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is Message<T> & { headers: { txids?: Array<Txid> } } {
   return `txids` in message.headers && Array.isArray(message.headers.txids)
 }
@@ -307,7 +307,12 @@ function hasTxids<T extends Row<unknown>>(
  * Creates a deduplicated loadSubset handler for progressive/on-demand modes
  * Returns null for eager mode, or a DeduplicatedLoadSubset instance for other modes.
  * Handles fetching snapshots in progressive mode during buffering phase,
- * and requesting snapshots in on-demand mode
+ * and requesting snapshots in on-demand mode.
+ *
+ * When cursor expressions are provided (whereFrom/whereCurrent), makes two
+ * requestSnapshot calls:
+ * - One for whereFrom (rows > cursor) with limit
+ * - One for whereCurrent (rows = cursor, for tie-breaking) without limit
  */
 function createLoadSubsetDedupe<T extends Row<unknown>>({
   stream,
@@ -347,7 +352,7 @@ function createLoadSubsetDedupe<T extends Row<unknown>>({
         // and completed the atomic swap while waiting for the snapshot
         if (!isBufferingInitialSync()) {
           debug(
-            `${collectionId ? `[${collectionId}] ` : ``}Ignoring snapshot - sync completed while fetching`
+            `${collectionId ? `[${collectionId}] ` : ``}Ignoring snapshot - sync completed while fetching`,
           )
           return
         }
@@ -367,13 +372,13 @@ function createLoadSubsetDedupe<T extends Row<unknown>>({
           commit()
 
           debug(
-            `${collectionId ? `[${collectionId}] ` : ``}Applied snapshot with ${rows.length} rows`
+            `${collectionId ? `[${collectionId}] ` : ``}Applied snapshot with ${rows.length} rows`,
           )
         }
       } catch (error) {
         debug(
           `${collectionId ? `[${collectionId}] ` : ``}Error fetching snapshot: %o`,
-          error
+          error,
         )
         throw error
       }
@@ -382,8 +387,50 @@ function createLoadSubsetDedupe<T extends Row<unknown>>({
       return
     } else {
       // On-demand mode: use requestSnapshot
-      const snapshotParams = compileSQL<T>(opts)
-      await stream.requestSnapshot(snapshotParams)
+      // When cursor is provided, make two calls:
+      // 1. whereCurrent (all ties, no limit)
+      // 2. whereFrom (rows > cursor, with limit)
+      const { cursor, where, orderBy, limit } = opts
+
+      if (cursor) {
+        // Make parallel requests for cursor-based pagination
+        const promises: Array<Promise<unknown>> = []
+
+        // Request 1: All rows matching whereCurrent (ties at boundary, no limit)
+        // Combine main where with cursor.whereCurrent
+        const whereCurrentOpts: LoadSubsetOptions = {
+          where: where ? and(where, cursor.whereCurrent) : cursor.whereCurrent,
+          orderBy,
+          // No limit - get all ties
+        }
+        const whereCurrentParams = compileSQL<T>(whereCurrentOpts)
+        promises.push(stream.requestSnapshot(whereCurrentParams))
+
+        debug(
+          `${collectionId ? `[${collectionId}] ` : ``}Requesting cursor.whereCurrent snapshot (all ties)`,
+        )
+
+        // Request 2: Rows matching whereFrom (rows > cursor, with limit)
+        // Combine main where with cursor.whereFrom
+        const whereFromOpts: LoadSubsetOptions = {
+          where: where ? and(where, cursor.whereFrom) : cursor.whereFrom,
+          orderBy,
+          limit,
+        }
+        const whereFromParams = compileSQL<T>(whereFromOpts)
+        promises.push(stream.requestSnapshot(whereFromParams))
+
+        debug(
+          `${collectionId ? `[${collectionId}] ` : ``}Requesting cursor.whereFrom snapshot (with limit ${limit})`,
+        )
+
+        // Wait for both requests to complete
+        await Promise.all(promises)
+      } else {
+        // No cursor - standard single request
+        const snapshotParams = compileSQL<T>(opts)
+        await stream.requestSnapshot(snapshotParams)
+      }
     }
   }
 
@@ -400,7 +447,7 @@ export type AwaitTxIdFn = (txId: Txid, timeout?: number) => Promise<boolean>
  */
 export type AwaitMatchFn<T extends Row<unknown>> = (
   matchFn: MatchFunction<T>,
-  timeout?: number
+  timeout?: number,
 ) => Promise<boolean>
 
 /**
@@ -427,7 +474,7 @@ export interface ElectricCollectionUtils<
 export function electricCollectionOptions<T extends StandardSchemaV1>(
   config: ElectricCollectionConfig<InferSchemaOutput<T>, T> & {
     schema: T
-  }
+  },
 ): Omit<CollectionConfig<InferSchemaOutput<T>, string | number, T>, `utils`> & {
   id?: string
   utils: ElectricCollectionUtils<InferSchemaOutput<T>>
@@ -438,7 +485,7 @@ export function electricCollectionOptions<T extends StandardSchemaV1>(
 export function electricCollectionOptions<T extends Row<unknown>>(
   config: ElectricCollectionConfig<T> & {
     schema?: never // prohibit schema
-  }
+  },
 ): Omit<CollectionConfig<T, string | number>, `utils`> & {
   id?: string
   utils: ElectricCollectionUtils<T>
@@ -446,7 +493,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
 }
 
 export function electricCollectionOptions<T extends Row<unknown>>(
-  config: ElectricCollectionConfig<T, any>
+  config: ElectricCollectionConfig<T, any>,
 ): Omit<
   CollectionConfig<T, string | number, any, ElectricCollectionUtils<T>>,
   `utils`
@@ -501,7 +548,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
         matchesToResolve.push(matchId)
         debug(
           `${config.id ? `[${config.id}] ` : ``}awaitMatch resolved on up-to-date for match %s`,
-          matchId
+          matchId,
         )
       }
     })
@@ -527,11 +574,11 @@ export function electricCollectionOptions<T extends Row<unknown>>(
    */
   const awaitTxId: AwaitTxIdFn = async (
     txId: Txid,
-    timeout: number = 5000
+    timeout: number = 5000,
   ): Promise<boolean> => {
     debug(
       `${config.id ? `[${config.id}] ` : ``}awaitTxId called with txid %d`,
-      txId
+      txId,
     )
     if (typeof txId !== `number`) {
       throw new ExpectedNumberInAwaitTxIdError(typeof txId, config.id)
@@ -543,7 +590,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
 
     // Then check if the txid is in any of the seen snapshots
     const hasSnapshot = seenSnapshots.state.some((snapshot) =>
-      isVisibleInSnapshot(txId, snapshot)
+      isVisibleInSnapshot(txId, snapshot),
     )
     if (hasSnapshot) return true
 
@@ -558,7 +605,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
         if (seenTxids.state.has(txId)) {
           debug(
             `${config.id ? `[${config.id}] ` : ``}awaitTxId found match for txid %o`,
-            txId
+            txId,
           )
           clearTimeout(timeoutId)
           unsubscribeSeenTxids()
@@ -569,13 +616,13 @@ export function electricCollectionOptions<T extends Row<unknown>>(
 
       const unsubscribeSeenSnapshots = seenSnapshots.subscribe(() => {
         const visibleSnapshot = seenSnapshots.state.find((snapshot) =>
-          isVisibleInSnapshot(txId, snapshot)
+          isVisibleInSnapshot(txId, snapshot),
         )
         if (visibleSnapshot) {
           debug(
             `${config.id ? `[${config.id}] ` : ``}awaitTxId found match for txid %o in snapshot %o`,
             txId,
-            visibleSnapshot
+            visibleSnapshot,
           )
           clearTimeout(timeoutId)
           unsubscribeSeenSnapshots()
@@ -594,10 +641,10 @@ export function electricCollectionOptions<T extends Row<unknown>>(
    */
   const awaitMatch: AwaitMatchFn<any> = async (
     matchFn: MatchFunction<any>,
-    timeout: number = 3000
+    timeout: number = 3000,
   ): Promise<boolean> => {
     debug(
-      `${config.id ? `[${config.id}] ` : ``}awaitMatch called with custom function`
+      `${config.id ? `[${config.id}] ` : ``}awaitMatch called with custom function`,
     )
 
     return new Promise((resolve, reject) => {
@@ -623,7 +670,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
       const checkMatch = (message: Message<any>) => {
         if (matchFn(message)) {
           debug(
-            `${config.id ? `[${config.id}] ` : ``}awaitMatch found matching message, waiting for up-to-date`
+            `${config.id ? `[${config.id}] ` : ``}awaitMatch found matching message, waiting for up-to-date`,
           )
           // Mark as matched but don't resolve yet - wait for up-to-date
           pendingMatches.setState((current) => {
@@ -643,7 +690,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
       for (const message of currentBatchMessages.state) {
         if (matchFn(message)) {
           debug(
-            `${config.id ? `[${config.id}] ` : ``}awaitMatch found immediate match in current batch, waiting for up-to-date`
+            `${config.id ? `[${config.id}] ` : ``}awaitMatch found immediate match in current batch, waiting for up-to-date`,
           )
           // Register match as already matched
           pendingMatches.setState((current) => {
@@ -681,7 +728,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
    * Process matching strategy and wait for synchronization
    */
   const processMatchingStrategy = async (
-    result: MatchingStrategy
+    result: MatchingStrategy,
   ): Promise<void> => {
     // Only wait if result contains txid
     if (result && `txid` in result) {
@@ -703,7 +750,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
           any,
           string | number,
           ElectricCollectionUtils<T>
-        >
+        >,
       ) => {
         const handlerResult = await config.onInsert!(params)
         await processMatchingStrategy(handlerResult)
@@ -717,7 +764,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
           any,
           string | number,
           ElectricCollectionUtils<T>
-        >
+        >,
       ) => {
         const handlerResult = await config.onUpdate!(params)
         await processMatchingStrategy(handlerResult)
@@ -731,7 +778,7 @@ export function electricCollectionOptions<T extends Row<unknown>>(
           any,
           string | number,
           ElectricCollectionUtils<T>
-        >
+        >,
       ) => {
         const handlerResult = await config.onDelete!(params)
         await processMatchingStrategy(handlerResult)
@@ -788,7 +835,7 @@ function createElectricSync<T extends Row<unknown>>(
     resolveMatchedPendingMatches: () => void
     collectionId?: string
     testHooks?: ElectricTestHooks
-  }
+  },
 ): SyncConfig<T> {
   const {
     seenTxids,
@@ -858,7 +905,7 @@ function createElectricSync<T extends Row<unknown>>(
           },
           {
             once: true,
-          }
+          },
         )
         if (shapeOptions.signal.aborted) {
           abortController.abort()
@@ -900,7 +947,7 @@ function createElectricSync<T extends Row<unknown>>(
               `An error occurred while syncing collection: ${collection.id}, \n` +
                 `it has been marked as ready to avoid blocking apps waiting for '.preload()' to finish. \n` +
                 `You can provide an 'onError' handler on the shapeOptions to handle this error, and this message will not be logged.`,
-              errorParams
+              errorParams,
             )
           }
 
@@ -965,7 +1012,7 @@ function createElectricSync<T extends Row<unknown>>(
                 // If matchFn throws, clean up and reject the promise
                 clearTimeout(match.timeoutId)
                 match.reject(
-                  err instanceof Error ? err : new Error(String(err))
+                  err instanceof Error ? err : new Error(String(err)),
                 )
                 matchesToRemove.push(matchId)
                 debug(`matchFn error: %o`, err)
@@ -1013,7 +1060,7 @@ function createElectricSync<T extends Row<unknown>>(
             hasUpToDate = true
           } else if (isMustRefetchMessage(message)) {
             debug(
-              `${collectionId ? `[${collectionId}] ` : ``}Received must-refetch message, starting transaction with truncate`
+              `${collectionId ? `[${collectionId}] ` : ``}Received must-refetch message, starting transaction with truncate`,
             )
 
             // Start a transaction and truncate the collection
@@ -1040,7 +1087,7 @@ function createElectricSync<T extends Row<unknown>>(
           // PROGRESSIVE MODE: Atomic swap on first up-to-date
           if (isBufferingInitialSync() && hasUpToDate) {
             debug(
-              `${collectionId ? `[${collectionId}] ` : ``}Progressive mode: Performing atomic swap with ${bufferedMessages.length} buffered messages`
+              `${collectionId ? `[${collectionId}] ` : ``}Progressive mode: Performing atomic swap with ${bufferedMessages.length} buffered messages`,
             )
 
             // Start atomic swap transaction
@@ -1063,7 +1110,7 @@ function createElectricSync<T extends Row<unknown>>(
                 // Extract txids from buffered messages (will be committed to store after transaction)
                 if (hasTxids(bufferedMsg)) {
                   bufferedMsg.headers.txids?.forEach((txid) =>
-                    newTxids.add(txid)
+                    newTxids.add(txid),
                   )
                 }
               } else if (isSnapshotEndMessage(bufferedMsg)) {
@@ -1080,7 +1127,7 @@ function createElectricSync<T extends Row<unknown>>(
             bufferedMessages.length = 0
 
             debug(
-              `${collectionId ? `[${collectionId}] ` : ``}Progressive mode: Atomic swap complete, now in normal sync mode`
+              `${collectionId ? `[${collectionId}] ` : ``}Progressive mode: Atomic swap complete, now in normal sync mode`,
             )
           } else {
             // Normal mode or on-demand: commit transaction if one was started
@@ -1115,7 +1162,7 @@ function createElectricSync<T extends Row<unknown>>(
             if (newTxids.size > 0) {
               debug(
                 `${collectionId ? `[${collectionId}] ` : ``}new txids synced from pg %O`,
-                Array.from(newTxids)
+                Array.from(newTxids),
               )
             }
             newTxids.forEach((txid) => clonedSeen.add(txid))
@@ -1129,8 +1176,8 @@ function createElectricSync<T extends Row<unknown>>(
             newSnapshots.forEach((snapshot) =>
               debug(
                 `${collectionId ? `[${collectionId}] ` : ``}new snapshot synced from pg %o`,
-                snapshot
-              )
+                snapshot,
+              ),
             )
             newSnapshots.length = 0
             return seen

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { TanStackDBError } from "@tanstack/db"
+import { TanStackDBError } from '@tanstack/db'
 
 // Electric DB Collection Errors
 export class ElectricDBCollectionError extends TanStackDBError {

package/src/index.ts

@@ -4,6 +4,6 @@ export {
   type ElectricCollectionUtils,
   type Txid,
   type AwaitTxIdFn,
-} from "./electric"
+} from './electric'
 
-export * from "./errors"
+export * from './errors'

package/src/sql-compiler.ts

@@ -1,6 +1,6 @@
-import { serialize } from "./pg-serializer"
-import type { SubsetParams } from "@electric-sql/client"
-import type { IR, LoadSubsetOptions } from "@tanstack/db"
+import { serialize } from './pg-serializer'
+import type { SubsetParams } from '@electric-sql/client'
+import type { IR, LoadSubsetOptions } from '@tanstack/db'
 
 export type CompiledSqlRecord = Omit<SubsetParams, `params`> & {
   params?: Array<unknown>
@@ -45,7 +45,7 @@ export function compileSQL<T>(options: LoadSubsetOptions): SubsetParams {
       }
       return acc
     },
-    {} as Record<string, string>
+    {} as Record<string, string>,
   )
 
   return {
@@ -72,7 +72,7 @@ function quoteIdentifier(name: string): string {
  */
 function compileBasicExpression(
   exp: IR.BasicExpression<unknown>,
-  params: Array<unknown>
+  params: Array<unknown>,
 ): string {
   switch (exp.type) {
     case `val`:
@@ -82,7 +82,7 @@ function compileBasicExpression(
       // TODO: doesn't yet support JSON(B) values which could be accessed with nested props
       if (exp.path.length !== 1) {
         throw new Error(
-          `Compiler can't handle nested properties: ${exp.path.join(`.`)}`
+          `Compiler can't handle nested properties: ${exp.path.join(`.`)}`,
         )
       }
       return quoteIdentifier(exp.path[0]!)
@@ -95,14 +95,14 @@ function compileBasicExpression(
 
 function compileOrderBy(orderBy: IR.OrderBy, params: Array<unknown>): string {
   const compiledOrderByClauses = orderBy.map((clause: IR.OrderByClause) =>
-    compileOrderByClause(clause, params)
+    compileOrderByClause(clause, params),
   )
   return compiledOrderByClauses.join(`,`)
 }
 
 function compileOrderByClause(
   clause: IR.OrderByClause,
-  params: Array<unknown>
+  params: Array<unknown>,
 ): string {
   // FIXME: We should handle stringSort and locale.
   //        Correctly supporting them is tricky as it depends on Postgres' collation
@@ -126,14 +126,14 @@ function compileOrderByClause(
 
 function compileFunction(
   exp: IR.Func<unknown>,
-  params: Array<unknown> = []
+  params: Array<unknown> = [],
 ): string {
   const { name, args } = exp
 
   const opName = getOpName(name)
 
   const compiledArgs = args.map((arg: IR.BasicExpression) =>
-    compileBasicExpression(arg, params)
+    compileBasicExpression(arg, params),
   )
 
   // Special case for IS NULL / IS NOT NULL - these are postfix operators
@@ -172,6 +172,120 @@ function compileFunction(
       throw new Error(`Binary operator ${name} expects 2 arguments`)
     }
     const [lhs, rhs] = compiledArgs
+
+    // Special case for comparison operators with boolean values
+    // PostgreSQL doesn't support < > <= >= on booleans
+    // Transform to equivalent equality checks or constant expressions
+    if (isComparisonOp(name)) {
+      const lhsArg = args[0]
+      const rhsArg = args[1]
+
+      // Check if RHS is a boolean literal value
+      if (
+        rhsArg &&
+        rhsArg.type === `val` &&
+        typeof rhsArg.value === `boolean`
+      ) {
+        const boolValue = rhsArg.value
+        // Remove the boolean param we just added since we'll transform the expression
+        params.pop()
+
+        // Transform based on operator and boolean value
+        // Boolean ordering: false < true
+        if (name === `lt`) {
+          if (boolValue === true) {
+            // lt(col, true) → col = false (only false is less than true)
+            params.push(false)
+            return `${lhs} = $${params.length}`
+          } else {
+            // lt(col, false) → nothing is less than false
+            return `false`
+          }
+        } else if (name === `gt`) {
+          if (boolValue === false) {
+            // gt(col, false) → col = true (only true is greater than false)
+            params.push(true)
+            return `${lhs} = $${params.length}`
+          } else {
+            // gt(col, true) → nothing is greater than true
+            return `false`
+          }
+        } else if (name === `lte`) {
+          if (boolValue === true) {
+            // lte(col, true) → everything is ≤ true
+            return `true`
+          } else {
+            // lte(col, false) → col = false
+            params.push(false)
+            return `${lhs} = $${params.length}`
+          }
+        } else if (name === `gte`) {
+          if (boolValue === false) {
+            // gte(col, false) → everything is ≥ false
+            return `true`
+          } else {
+            // gte(col, true) → col = true
+            params.push(true)
+            return `${lhs} = $${params.length}`
+          }
+        }
+      }
+
+      // Check if LHS is a boolean literal value (less common but handle it)
+      if (
+        lhsArg &&
+        lhsArg.type === `val` &&
+        typeof lhsArg.value === `boolean`
+      ) {
+        const boolValue = lhsArg.value
+        // Remove params for this expression and rebuild
+        params.pop() // remove RHS
+        params.pop() // remove LHS (boolean)
+
+        // Recompile RHS to get fresh param
+        const rhsCompiled = compileBasicExpression(rhsArg!, params)
+
+        // Transform: flip the comparison (val op col → col flipped_op val)
+        if (name === `lt`) {
+          // lt(true, col) → gt(col, true) → col > true → nothing is greater than true
+          if (boolValue === true) {
+            return `false`
+          } else {
+            // lt(false, col) → gt(col, false) → col = true
+            params.push(true)
+            return `${rhsCompiled} = $${params.length}`
+          }
+        } else if (name === `gt`) {
+          // gt(true, col) → lt(col, true) → col = false
+          if (boolValue === true) {
+            params.push(false)
+            return `${rhsCompiled} = $${params.length}`
+          } else {
+            // gt(false, col) → lt(col, false) → nothing is less than false
+            return `false`
+          }
+        } else if (name === `lte`) {
+          if (boolValue === false) {
+            // lte(false, col) → gte(col, false) → everything
+            return `true`
+          } else {
+            // lte(true, col) → gte(col, true) → col = true
+            params.push(true)
+            return `${rhsCompiled} = $${params.length}`
+          }
+        } else if (name === `gte`) {
+          if (boolValue === true) {
+            // gte(true, col) → lte(col, true) → everything
+            return `true`
+          } else {
+            // gte(false, col) → lte(col, false) → col = false
+            params.push(false)
+            return `${rhsCompiled} = $${params.length}`
+          }
+        }
+      }
+    }
+
     // Special case for = ANY operator which needs parentheses around the array parameter
     if (name === `in`) {
       return `${lhs} ${opName}(${rhs})`
@@ -198,6 +312,14 @@ function isBinaryOp(name: string): boolean {
   return binaryOps.includes(name)
 }
 
+/**
+ * Checks if the operator is a comparison operator (excluding eq)
+ * These operators don't work on booleans in PostgreSQL without casting
+ */
+function isComparisonOp(name: string): boolean {
+  return [`gt`, `gte`, `lt`, `lte`].includes(name)
+}
+
 function getOpName(name: string): string {
   const opNames = {
     eq: `=`,