@teleporthq/teleport-plugin-next-data-source 0.44.7 → 0.44.12

package/src/fetchers/mariadb.ts

@@ -5,6 +5,7 @@ import {
   generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import { generateSearchSqlHelpersCode, MARIADB_SEARCH_MATCH_SQL } from '../search-relevance'
 
 interface MariaDBConfig {
   host?: string
@@ -31,6 +32,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(MARIADB_SEARCH_MATCH_SQL)}
 
 // Helper function to process filters and build conditions
 const processFilters = (filters, conditions, queryParams) => {
@@ -110,6 +112,7 @@ export default async function handler(req, res) {
     
     const conditions = []
     const queryParams = []
+    let search = null
     
     if (query) {
       let columns = []
@@ -135,14 +138,10 @@ export default async function handler(req, res) {
         }
       }
       
-      if (columns.length > 0) {
-        const pattern = "%" + escapeLikePattern(query) + "%"
-        const searchConditions = columns.map(
-          (col) =>
-            "LOWER(CAST(\`" + sanitizeSearchIdentifier(col) + "\` AS CHAR)) LIKE LOWER(?) ESCAPE '|'"
-        )
-        columns.forEach(() => queryParams.push(pattern))
-        conditions.push("(" + searchConditions.join(" OR ") + ")")
+      search = buildSearchSql(query, columns)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
       }
     }
 
@@ -155,22 +154,24 @@ export default async function handler(req, res) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
     }
     
-    // Handle sorts - new array format
+    // Handle sorts - new array format. A search orders its matches by where
+    // the words are first; the sort orders the rows within each of those groups.
+    const orderClauses = search && search.rank ? [search.rank] : []
     if (sorts) {
       const parsedSorts = safeJSONParse(sorts)
       if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
-        const orderClauses = parsedSorts.map((sort) => {
+        orderClauses.push(...parsedSorts.map((sort) => {
           if (!sort.field) return null
           const order = (sort.order || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
           return \`\\\`\${sort.field}\\\` \${order}\`
-        }).filter(Boolean)
-
-        if (orderClauses.length > 0) {
-          sql += \` ORDER BY \${orderClauses.join(', ')}\`
-        }
+        }).filter(Boolean))
       }
     } else if (sortBy) {
-      sql += \` ORDER BY \\\`\${sortBy}\\\` \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`
+      orderClauses.push(\`\\\`\${sortBy}\\\` \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`)
+    }
+    if (orderClauses.length > 0) {
+      sql += \` ORDER BY \${orderClauses.join(', ')}\`
+      if (search && search.rank) queryParams.push(...search.rankParams)
     }
     
     const limitValue = limit || perPage
@@ -284,16 +285,10 @@ async function getCount(req, res) {
         }
       }
       
-      if (columns.length > 0) {
-        const pattern = "%" + escapeLikePattern(query) + "%"
-        const searchConditions = columns
-          .map(
-            (col) =>
-              "LOWER(CAST(\`" + sanitizeSearchIdentifier(col) + "\` AS CHAR)) LIKE LOWER(?) ESCAPE '|'"
-          )
-          .join(" OR ")
-        conditions.push("(" + searchConditions + ")")
-        columns.forEach(() => queryParams.push(pattern))
+      const search = buildSearchSql(query, columns)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
       }
     }
 

package/src/fetchers/mysql.ts

@@ -5,6 +5,7 @@ import {
   generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import { generateSearchSqlHelpersCode, MYSQL_SEARCH_MATCH_SQL } from '../search-relevance'
 
 interface MySQLConfig {
   host?: string
@@ -68,6 +69,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(MYSQL_SEARCH_MATCH_SQL)}
 
 // Helper function to process filters and build conditions
 const processFilters = (filters, conditions, queryParams) => {
@@ -119,6 +121,7 @@ export default async function handler(req, res) {
     
     const conditions = []
     const queryParams = []
+    let search = null
     
     if (query) {
       let columns = []
@@ -144,14 +147,10 @@ export default async function handler(req, res) {
         }
       }
       
-      if (columns.length > 0) {
-        const pattern = "%" + escapeLikePattern(query) + "%"
-        const searchConditions = columns.map(
-          (col) =>
-            "LOWER(CAST(" + mysql.escapeId(sanitizeSearchIdentifier(col)) + " AS CHAR)) LIKE LOWER(?) ESCAPE '|'"
-        )
-        columns.forEach(() => queryParams.push(pattern))
-        conditions.push("(" + searchConditions.join(" OR ") + ")")
+      search = buildSearchSql(query, columns)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
       }
     }
 
@@ -164,22 +163,24 @@ export default async function handler(req, res) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
     }
     
-    // Handle sorts - new array format
+    // Handle sorts - new array format. A search orders its matches by where
+    // the words are first; the sort orders the rows within each of those groups.
+    const orderClauses = search && search.rank ? [search.rank] : []
     if (sorts) {
       const parsedSorts = safeJSONParse(sorts)
       if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
-        const orderClauses = parsedSorts.map((sort) => {
+        orderClauses.push(...parsedSorts.map((sort) => {
           if (!sort.field) return null
           const order = (sort.order || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
           return \`\${mysql.escapeId(sort.field)} \${order}\`
-        }).filter(Boolean)
-
-        if (orderClauses.length > 0) {
-          sql += \` ORDER BY \${orderClauses.join(', ')}\`
-        }
+        }).filter(Boolean))
       }
     } else if (sortBy) {
-      sql += \` ORDER BY \${mysql.escapeId(sortBy)} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`
+      orderClauses.push(\`\${mysql.escapeId(sortBy)} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`)
+    }
+    if (orderClauses.length > 0) {
+      sql += \` ORDER BY \${orderClauses.join(', ')}\`
+      if (search && search.rank) queryParams.push(...search.rankParams)
     }
     
     const limitValue = limit || perPage
@@ -263,16 +264,10 @@ async function getCount(req, res) {
         }
       }
       
-      if (columns.length > 0) {
-        const pattern = "%" + escapeLikePattern(query) + "%"
-        const searchConditions = columns
-          .map(
-            (col) =>
-              "LOWER(CAST(" + mysql.escapeId(sanitizeSearchIdentifier(col)) + " AS CHAR)) LIKE LOWER(?) ESCAPE '|'"
-          )
-          .join(" OR ")
-        conditions.push("(" + searchConditions + ")")
-        columns.forEach(() => queryParams.push(pattern))
+      const search = buildSearchSql(query, columns)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
       }
     }
 

package/src/fetchers/postgresql.ts

@@ -10,6 +10,7 @@ import { SORT_NULLS_LAST_SQL } from '../list-sort-order'
 import { generateRowOrderTiebreakHelper, rowIdentityColumn } from '../row-order'
 import { generateProductFilterClauseHelper } from '../product-filter-fields'
 import { generateReadGuardCall, generateTableAccessPreamble } from './utils/table-access-guard'
+import { generateSearchSqlHelpersCode, PG_SEARCH_MATCH_SQL } from '../search-relevance'
 import { generateRequestSqlGuardsCode } from './utils/request-sql-guards'
 import { generateArrayOverlapSqlCode } from '../array-overlap-sql'
 import { PG_CLIENT_IMPORT } from './pg-client-import'
@@ -72,6 +73,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(PG_SEARCH_MATCH_SQL)}
 ${generateArrayOverlapSqlCode()}
 
 // Builds one SQL clause for the whole filter tree, so an OR group nested in
@@ -173,6 +175,7 @@ ${generateReadGuardCall(tableName, null)}
     const conditions = []
     const queryParams = []
     let paramIndex = 1
+    let searchRank = ''
     
     if (query) {
       let columns = []
@@ -205,15 +208,12 @@ ${generateReadGuardCall(tableName, null)}
       }
       if (__rowPolicy) columns = __brpVisibleColumns(__rowPolicy, columns)
       
-      if (columns.length > 0) {
-        const pattern = '%' + escapeLikePattern(query) + '%'
-        const placeholder = '$' + paramIndex
-        paramIndex++
-        queryParams.push(pattern)
-        const searchConditions = columns.map(
-          (col) => '"' + sanitizeSearchIdentifier(col) + '"::text ILIKE ' + placeholder + " ESCAPE '|'"
-        )
-        conditions.push('(' + searchConditions.join(' OR ') + ')')
+      const search = buildSearchSql(query, columns, paramIndex)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
+        paramIndex = search.nextIndex
+        searchRank = search.rank
       }
     }
 
@@ -230,8 +230,11 @@ ${generateReadGuardCall(tableName, null)}
     // Handle sorts - new array format. Two ORDER BY clauses are built: the one
     // actually used (the products table's price rewrites, rows without a value
     // last), and a plain-column twin kept only as the fallback below.
+    // A search orders its matches by where the words are first; the sort
+    // orders the rows within each of those groups.
     let orderBySql = ''
     let plainOrderBySql = ''
+    const searchOrder = searchRank ? searchRank + ', ' : ''
     if (sorts) {
       const parsedSorts = safeJSONParse(sorts)
       if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
@@ -245,16 +248,19 @@ ${generateReadGuardCall(tableName, null)}
           // The row's own key last, so equal rows can't repeat across pages
           // or vanish between them.
           const tiebreak = rowOrderTiebreak(valid.map((sort) => sort.field), orderOf(valid[valid.length - 1]))
-          orderBySql = \` ORDER BY \${orderClauses.join(', ')}\${tiebreak}\`
-          plainOrderBySql = \` ORDER BY \${plainClauses.join(', ')}\${tiebreak}\`
+          orderBySql = \` ORDER BY \${searchOrder}\${orderClauses.join(', ')}\${tiebreak}\`
+          plainOrderBySql = \` ORDER BY \${searchOrder}\${plainClauses.join(', ')}\${tiebreak}\`
         }
       }
     } else if (sortBy) {
       assertRequestColumn(sortBy, 'sort field')
       const sortByDirection = (sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
       const tiebreak = rowOrderTiebreak([sortBy], sortByDirection)
-      orderBySql = \` ORDER BY \${sortBy} \${sortByDirection}${SORT_NULLS_LAST_SQL}\${tiebreak}\`
-      plainOrderBySql = \` ORDER BY \${sortBy} \${sortByDirection}\${tiebreak}\`
+      orderBySql = \` ORDER BY \${searchOrder}\${sortBy} \${sortByDirection}${SORT_NULLS_LAST_SQL}\${tiebreak}\`
+      plainOrderBySql = \` ORDER BY \${searchOrder}\${sortBy} \${sortByDirection}\${tiebreak}\`
+    }
+    if (!orderBySql && searchRank) {
+      orderBySql = plainOrderBySql = ' ORDER BY ' + searchRank + rowOrderTiebreak([], 'ASC')
     }
     const usedRewrittenSort = orderBySql !== plainOrderBySql
 
@@ -379,17 +385,11 @@ ${generateReadGuardCall(tableName, null)}
       }
       if (__rowPolicy) columns = __brpVisibleColumns(__rowPolicy, columns)
       
-      if (columns.length > 0) {
-        const pattern = '%' + escapeLikePattern(query) + '%'
-        const placeholder = '$' + paramIndex
-        paramIndex++
-        queryParams.push(pattern)
-        const searchConditions = columns
-          .map(
-            (col) => '"' + sanitizeSearchIdentifier(col) + '"::text ILIKE ' + placeholder + " ESCAPE '|'"
-          )
-          .join(' OR ')
-        conditions.push('(' + searchConditions + ')')
+      const search = buildSearchSql(query, columns, paramIndex)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
+        paramIndex = search.nextIndex
       }
     }
 

package/src/fetchers/redshift.ts

@@ -5,6 +5,7 @@ import {
   generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import { generateSearchSqlHelpersCode, PG_SEARCH_MATCH_SQL } from '../search-relevance'
 
 interface RedshiftConfig {
   host?: string
@@ -60,6 +61,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(PG_SEARCH_MATCH_SQL)}
 
 ${generateDateFormatterCode()}
 
@@ -75,6 +77,7 @@ export default async function handler(req, res) {
     const conditions = []
     const queryParams = []
     let paramIndex = 1
+    let search = null
     
     if (query) {
       let columns = []
@@ -100,15 +103,11 @@ export default async function handler(req, res) {
         }
       }
       
-      if (columns.length > 0) {
-        const pattern = '%' + escapeLikePattern(query) + '%'
-        const placeholder = '$' + paramIndex
-        paramIndex++
-        queryParams.push(pattern)
-        const searchConditions = columns.map(
-          (col) => '"' + sanitizeSearchIdentifier(col) + '"::text ILIKE ' + placeholder + " ESCAPE '|'"
-        )
-        conditions.push('(' + searchConditions.join(' OR ') + ')')
+      search = buildSearchSql(query, columns, paramIndex)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
+        paramIndex = search.nextIndex
       }
     }
     
@@ -166,22 +165,24 @@ export default async function handler(req, res) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
     }
     
-    // Handle sorts - new array format
+    // Handle sorts - new array format. A search orders its matches by where
+    // the words are first; the sort orders the rows within each of those groups.
+    const orderClauses = search && search.rank ? [search.rank] : []
     if (sorts) {
       const parsedSorts = safeJSONParse(sorts)
       if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
-        const orderClauses = parsedSorts.map((sort) => {
+        orderClauses.push(...parsedSorts.map((sort) => {
           if (!sort.field) return null
           const order = (sort.order || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
           return \`\${sanitizeIdentifier(sort.field)} \${order}\`
-        }).filter(Boolean)
-
-        if (orderClauses.length > 0) {
-          sql += \` ORDER BY \${orderClauses.join(', ')}\`
-        }
+        }).filter(Boolean))
       }
     } else if (sortBy) {
-      sql += \` ORDER BY \${sanitizeIdentifier(sortBy)} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`
+      orderClauses.push(\`\${sanitizeIdentifier(sortBy)} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`)
+    }
+    if (orderClauses.length > 0) {
+      sql += \` ORDER BY \${orderClauses.join(', ')}\`
+      if (search && search.rank) queryParams.push(...search.rankParams)
     }
     
     const limitValue = limit || perPage

package/src/fetchers/rest-api.ts

@@ -5,6 +5,7 @@ import {
   generateSafeJSONParseCode,
   generateFilterTreeHelpersCode,
 } from '../utils'
+import { generateSearchRankHelperCode } from '../search-relevance'
 import {
   RESTAPICacheConfig,
   generateRESTAPIResponseCacheCode,
@@ -124,6 +125,8 @@ export const generateRESTAPIFetcher = (config: Record<string, unknown>): string
 
 ${generateSafeJSONParseCode()}
 
+${generateSearchRankHelperCode()}
+
 ${generateDateFormatterCode()}
 
 ${generateSortFilterHelperCode()}
@@ -194,18 +197,18 @@ export default async function handler(req, res) {
     
     if (Array.isArray(data)) {
       if (query && query.trim()) {
-        const searchQuery = query.toLowerCase()
+        const searchTerms = query.toLowerCase().split(' ').filter(Boolean)
         
         if (queryColumns) {
           try {
             const parsed = safeJSONParse(queryColumns)
             const columns = Array.isArray(parsed) ? parsed : [parsed]
             data = data.filter((item) => {
-              return columns.some((col) => {
+              return searchTerms.every((term) => columns.some((col) => {
                 const value = getNestedValue(item, col)
                 if (value === null || value === undefined) return false
-                return String(value).toLowerCase().includes(searchQuery)
-              })
+                return String(value).toLowerCase().includes(term)
+              }))
             })
           } catch (err) {
             console.error('Error parsing queryColumns:', err)
@@ -214,7 +217,7 @@ export default async function handler(req, res) {
           data = data.filter((item) => {
             try {
               const stringified = JSON.stringify(item).toLowerCase()
-              return stringified.includes(searchQuery)
+              return searchTerms.every((term) => stringified.includes(term))
             } catch {
               return false
             }
@@ -310,6 +313,10 @@ export default async function handler(req, res) {
         })
       }
       
+      if (query && queryColumns) {
+        data = rankBySearch(data, query, safeJSONParse(queryColumns), getNestedValue)
+      }
+      
       const limitValue = limit || perPage
       const pageValue = page ? Math.max(1, parseInt(page)) : undefined
       const offsetValue = offset !== undefined ? Math.max(0, parseInt(offset)) : (pageValue && perPage ? (pageValue - 1) * Math.max(1, parseInt(perPage)) : 0)

package/src/fetchers/supabase.ts

@@ -5,6 +5,7 @@ import {
   generateSearchEscapeHelpersCode,
   generateFilterTreeHelpersCode,
 } from '../utils'
+import { generateSearchWordsCode } from '../search-relevance'
 
 export const validateSupabaseConfig = (
   config: Record<string, unknown>
@@ -131,6 +132,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchWordsCode()}
 
 // Helper function to process filter values
 const processFilterValue = (value) => {
@@ -354,16 +356,19 @@ export default async function handler(req, res) {
         // shared identifier sanitizer to reject injection. Note:
         // PostgREST .ilike. does not expose a LIKE ESCAPE clause, so
         // raw % / _ in the user input still act as wildcards in this
-        // backend; the canvas preview path escapes them explicitly.
-        const rawPattern = "%" + String(query) + "%"
-        const escapedForPostgrest = rawPattern
-          .replace(/\\\\/g, "\\\\\\\\")
-          .replace(/"/g, '\\\\"')
-        const searchPattern = '"' + escapedForPostgrest + '"'
-        const orConditions = columns
-          .map((col) => sanitizeSearchIdentifier(col) + ".ilike." + searchPattern)
-          .join(",")
-        queryRef = queryRef.or(orConditions)
+        // backend; the canvas preview path escapes them explicitly. Each
+        // typed word gets its own .or(), and PostgREST ANDs them.
+        searchWords(query).forEach((word) => {
+          const rawPattern = "%" + word + "%"
+          const escapedForPostgrest = rawPattern
+            .replace(/\\\\/g, "\\\\\\\\")
+            .replace(/"/g, '\\\\"')
+          const searchPattern = '"' + escapedForPostgrest + '"'
+          const orConditions = columns
+            .map((col) => sanitizeSearchIdentifier(col) + ".ilike." + searchPattern)
+            .join(",")
+          queryRef = queryRef.or(orConditions)
+        })
       }
     }
 
@@ -478,16 +483,18 @@ async function getCount(req, res) {
       if (columns.length > 0) {
         // Mirror the fetch handler: sanitize identifiers, wrap the
         // pattern in double quotes for PostgREST .or() DSL, and escape
-        // backslashes / quotes in the user's search term.
-        const rawPattern = "%" + String(query) + "%"
-        const escapedForPostgrest = rawPattern
-          .replace(/\\\\/g, "\\\\\\\\")
-          .replace(/"/g, '\\\\"')
-        const searchPattern = '"' + escapedForPostgrest + '"'
-        const orConditions = columns
-          .map((col) => sanitizeSearchIdentifier(col) + ".ilike." + searchPattern)
-          .join(",")
-        countQuery = countQuery.or(orConditions)
+        // backslashes / quotes in the user's search term, one .or() per word.
+        searchWords(query).forEach((word) => {
+          const rawPattern = "%" + word + "%"
+          const escapedForPostgrest = rawPattern
+            .replace(/\\\\/g, "\\\\\\\\")
+            .replace(/"/g, '\\\\"')
+          const searchPattern = '"' + escapedForPostgrest + '"'
+          const orConditions = columns
+            .map((col) => sanitizeSearchIdentifier(col) + ".ilike." + searchPattern)
+            .join(",")
+          countQuery = countQuery.or(orConditions)
+        })
       }
     }
 

package/src/fetchers/teleport.ts

@@ -20,6 +20,7 @@ import { REQUEST_LOCALE_PARAM } from '../request-locale'
 import { generateReadGuardCall, generateTableAccessPreamble } from './utils/table-access-guard'
 import { generateRequestSqlGuardsCode } from './utils/request-sql-guards'
 import { generateArrayOverlapSqlCode } from '../array-overlap-sql'
+import { generateSearchSqlHelpersCode, PG_SEARCH_MATCH_SQL } from '../search-relevance'
 import { PG_CLIENT_IMPORT } from './pg-client-import'
 
 interface TeleportDBConfig {
@@ -162,6 +163,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(PG_SEARCH_MATCH_SQL)}
 ${generateArrayOverlapSqlCode()}
 ${getTransformationCode(tableName, transformOptions)}
 ${getTransformWrapperCode(tableName, transformOptions)}
@@ -346,6 +348,7 @@ ${generateReadGuardCall(tableName, 'req.query && req.query.rawQuery')}
     const conditions = []
     const queryParams = []
     let paramIndex = 1
+    let searchRank = ''
     
     if (query) {
       let columns = []
@@ -376,15 +379,12 @@ ${generateReadGuardCall(tableName, 'req.query && req.query.rawQuery')}
       }
       if (__rowPolicy) columns = __brpVisibleColumns(__rowPolicy, columns)
       
-      if (columns.length > 0) {
-        const pattern = '%' + escapeLikePattern(query) + '%'
-        const placeholder = '$' + paramIndex
-        paramIndex++
-        queryParams.push(pattern)
-        const searchConditions = columns.map(
-          (col) => '"' + sanitizeSearchIdentifier(col) + '"::text ILIKE ' + placeholder + " ESCAPE '|'"
-        )
-        conditions.push('(' + searchConditions.join(' OR ') + ')')
+      const search = buildSearchSql(query, columns, paramIndex)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
+        paramIndex = search.nextIndex
+        searchRank = search.rank
       }
     }
     
@@ -401,8 +401,11 @@ ${generateReadGuardCall(tableName, 'req.query && req.query.rawQuery')}
     // actually used (a translatable column in the request's language, the
     // products table's price rewrites, rows without a value last), and a
     // plain-column twin kept only as the fallback below.
+    // A search orders its matches by where the words are first; the sort
+    // orders the rows within each of those groups.
     let orderBySql = ''
     let plainOrderBySql = ''
+    const searchOrder = searchRank ? searchRank + ', ' : ''
     if (sorts) {
       const parsedSorts = safeJSONParse(sorts)
       if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
@@ -416,16 +419,19 @@ ${generateReadGuardCall(tableName, 'req.query && req.query.rawQuery')}
           // The row's own key last, so equal rows can't repeat across pages
           // or vanish between them.
           const tiebreak = rowOrderTiebreak(valid.map((sort) => sort.field), orderOf(valid[valid.length - 1]))
-          orderBySql = \` ORDER BY \${orderClauses.join(', ')}\${tiebreak}\`
-          plainOrderBySql = \` ORDER BY \${plainClauses.join(', ')}\${tiebreak}\`
+          orderBySql = \` ORDER BY \${searchOrder}\${orderClauses.join(', ')}\${tiebreak}\`
+          plainOrderBySql = \` ORDER BY \${searchOrder}\${plainClauses.join(', ')}\${tiebreak}\`
         }
       }
     } else if (sortBy) {
       assertRequestColumn(sortBy, 'sort field')
       const sortByDirection = (sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
       const tiebreak = rowOrderTiebreak([sortBy], sortByDirection)
-      orderBySql = \` ORDER BY \${localizedSortFieldSql(sortBy, requestLocale) || sortBy} \${sortByDirection}${SORT_NULLS_LAST_SQL}\${tiebreak}\`
-      plainOrderBySql = \` ORDER BY \${sortBy} \${sortByDirection}\${tiebreak}\`
+      orderBySql = \` ORDER BY \${searchOrder}\${localizedSortFieldSql(sortBy, requestLocale) || sortBy} \${sortByDirection}${SORT_NULLS_LAST_SQL}\${tiebreak}\`
+      plainOrderBySql = \` ORDER BY \${searchOrder}\${sortBy} \${sortByDirection}\${tiebreak}\`
+    }
+    if (!orderBySql && searchRank) {
+      orderBySql = plainOrderBySql = ' ORDER BY ' + searchRank + rowOrderTiebreak([], 'ASC')
     }
     const usedRewrittenSort = orderBySql !== plainOrderBySql
 
@@ -566,17 +572,11 @@ ${generateReadGuardCall(tableName, null)}
       }
       if (__rowPolicy) columns = __brpVisibleColumns(__rowPolicy, columns)
       
-      if (columns.length > 0) {
-        const pattern = '%' + escapeLikePattern(query) + '%'
-        const placeholder = '$' + paramIndex
-        paramIndex++
-        queryParams.push(pattern)
-        const searchConditions = columns
-          .map(
-            (col) => '"' + sanitizeSearchIdentifier(col) + '"::text ILIKE ' + placeholder + " ESCAPE '|'"
-          )
-          .join(' OR ')
-        conditions.push('(' + searchConditions + ')')
+      const search = buildSearchSql(query, columns, paramIndex)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
+        paramIndex = search.nextIndex
       }
     }