@teleporthq/teleport-plugin-next-data-source 0.44.11 → 0.44.13

package/src/fetchers/mysql.ts

@@ -5,6 +5,7 @@ import {
   generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import { generateSearchSqlHelpersCode, MYSQL_SEARCH_SQL } from '../search-relevance'
 
 interface MySQLConfig {
   host?: string
@@ -68,6 +69,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(MYSQL_SEARCH_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_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_SQL)}
 ${generateArrayOverlapSqlCode()}
 
 // Builds one SQL clause for the whole filter tree, so an OR group nested in
@@ -173,6 +175,8 @@ ${generateReadGuardCall(tableName, null)}
     const conditions = []
     const queryParams = []
     let paramIndex = 1
+    let searchRank = ''
+    let searchFrom = ''
     
     if (query) {
       let columns = []
@@ -205,15 +209,13 @@ ${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
+        searchFrom = search.from
       }
     }
 
@@ -221,7 +223,8 @@ ${generateReadGuardCall(tableName, null)}
     paramIndex = processFilters(filters, conditions, queryParams, paramIndex)
     if (__rowPolicy) conditions.push('(' + __rowPolicy.predicate + ')')
     
-    let sql = \`SELECT * FROM "${tableName}"\`
+    // A search's worked-out texts stay out of the rows: only the table's own columns.
+    let sql = \`SELECT \${searchFrom ? '"${tableName}".*' : '*'} FROM "${tableName}"\${searchFrom}\`
     
     if (conditions.length > 0) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
@@ -230,8 +233,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 +251,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
 
@@ -346,6 +355,7 @@ ${generateReadGuardCall(tableName, null)}
     const conditions = []
     const queryParams = []
     let paramIndex = 1
+    let searchFrom = ''
 
     if (query) {
       let columns = []
@@ -379,17 +389,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 '|'"
-          )
-          .join(' OR ')
-        conditions.push('(' + searchConditions + ')')
+      const search = buildSearchSql(query, columns, paramIndex)
+      if (search) {
+        conditions.push(search.where)
+        queryParams.push(...search.params)
+        paramIndex = search.nextIndex
+        searchFrom = search.from
       }
     }
 
@@ -397,7 +402,7 @@ ${generateReadGuardCall(tableName, null)}
     paramIndex = processFilters(filters, conditions, queryParams, paramIndex)
     if (__rowPolicy) conditions.push('(' + __rowPolicy.predicate + ')')
 
-    let countSql = \`SELECT COUNT(*) FROM "${tableName}"\`
+    let countSql = \`SELECT COUNT(*) FROM "${tableName}"\${searchFrom}\`
     if (conditions.length > 0) {
       countSql += \` WHERE \${conditions.join(' AND ')}\`
     }

package/src/fetchers/redshift.ts

@@ -5,6 +5,7 @@ import {
   generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import { generateSearchSqlHelpersCode, REDSHIFT_SEARCH_SQL } from '../search-relevance'
 
 interface RedshiftConfig {
   host?: string
@@ -60,6 +61,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(REDSHIFT_SEARCH_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,27 +197,20 @@ export default async function handler(req, res) {
     
     if (Array.isArray(data)) {
       if (query && query.trim()) {
-        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 searchTerms.every((term) => columns.some((col) => {
-                const value = getNestedValue(item, col)
-                if (value === null || value === undefined) return false
-                return String(value).toLowerCase().includes(term)
-              }))
-            })
+            data = data.filter((item) => matchesSearch(item, query, columns, getNestedValue))
           } catch (err) {
             console.error('Error parsing queryColumns:', err)
           }
         } else {
+          const terms = searchTerms(query)
           data = data.filter((item) => {
             try {
-              const stringified = JSON.stringify(item).toLowerCase()
-              return searchTerms.every((term) => stringified.includes(term))
+              const text = searchText(item)
+              return terms.every((term) => text.indexOf(term) !== -1)
             } catch {
               return false
             }
@@ -310,6 +306,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 { generateSearchTermsCode } from '../search-relevance'
 
 export const validateSupabaseConfig = (
   config: Record<string, unknown>
@@ -131,6 +132,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchTermsCode(false)}
 
 // 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.
+        searchTerms(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.
+        searchTerms(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_SQL } from '../search-relevance'
 import { PG_CLIENT_IMPORT } from './pg-client-import'
 
 interface TeleportDBConfig {
@@ -162,6 +163,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(PG_SEARCH_SQL)}
 ${generateArrayOverlapSqlCode()}
 ${getTransformationCode(tableName, transformOptions)}
 ${getTransformWrapperCode(tableName, transformOptions)}
@@ -346,6 +348,8 @@ ${generateReadGuardCall(tableName, 'req.query && req.query.rawQuery')}
     const conditions = []
     const queryParams = []
     let paramIndex = 1
+    let searchRank = ''
+    let searchFrom = ''
     
     if (query) {
       let columns = []
@@ -376,22 +380,21 @@ ${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
+        searchFrom = search.from
       }
     }
     
     paramIndex = processFilters(filters, conditions, queryParams, paramIndex)
     if (__rowPolicy) conditions.push('(' + __rowPolicy.predicate + ')')
     
-    let sql = \`SELECT * FROM ${tableName}\`
+    // A search's worked-out texts stay out of the rows: only the table's own columns.
+    let sql = \`SELECT \${searchFrom ? '${tableName}.*' : '*'} FROM ${tableName}\${searchFrom}\`
     
     if (conditions.length > 0) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
@@ -401,8 +404,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 +422,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
 
@@ -536,6 +545,7 @@ ${generateReadGuardCall(tableName, null)}
     const conditions = []
     const queryParams = []
     let paramIndex = 1
+    let searchFrom = ''
 
     if (query) {
       let columns = []
@@ -566,24 +576,19 @@ ${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
+        searchFrom = search.from
       }
     }
 
     paramIndex = processFilters(filters, conditions, queryParams, paramIndex)
     if (__rowPolicy) conditions.push('(' + __rowPolicy.predicate + ')')
 
-    let countSql = \`SELECT COUNT(*) FROM ${tableName}\`
+    let countSql = \`SELECT COUNT(*) FROM ${tableName}\${searchFrom}\`
     if (conditions.length > 0) {
       countSql += \` WHERE \${conditions.join(' AND ')}\`
     }

package/src/fetchers/turso.ts

@@ -5,6 +5,7 @@ import {
   generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import { generateSearchSqlHelpersCode, SQLITE_SEARCH_SQL } from '../search-relevance'
 
 export const validateTursoConfig = (
   config: Record<string, unknown>
@@ -46,6 +47,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(SQLITE_SEARCH_SQL)}
 
 ${generateDateFormatterCode()}
 
@@ -63,6 +65,7 @@ export default async function handler(req, res) {
     const whereClauses = []
     const queryParams = []
     let searchQueryColumns = null
+    let search = null
     
     if (query) {
       if (queryColumns) {
@@ -70,15 +73,11 @@ export default async function handler(req, res) {
         const columns = Array.isArray(parsed) ? parsed : [parsed]
         // Cast columns to TEXT and LOWER both sides so the match is
         // case-insensitive regardless of SQLite collation.
-        const pattern = "%" + escapeLikePattern(query) + "%"
-        const searchConditions = columns.map(
-          (col) =>
-            'LOWER(CAST("' + sanitizeSearchIdentifier(col) + '" AS TEXT)) LIKE LOWER(?) ESCAPE ' + "'|'"
-        )
-        whereClauses.push("(" + searchConditions.join(" OR ") + ")")
-        columns.forEach(() => {
-          queryParams.push(pattern)
-        })
+        search = buildSearchSql(query, columns)
+        if (search) {
+          whereClauses.push(search.where)
+          queryParams.push(...search.params)
+        }
       } else {
         // Store query for post-filtering if columns not specified
         searchQueryColumns = query
@@ -135,23 +134,25 @@ export default async function handler(req, res) {
       sql += \` WHERE \${whereClauses.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) {
       const sortOrderValue = (sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
-      sql += \` ORDER BY \${sanitizeIdentifier(sortBy)} \${sortOrderValue}\`
+      orderClauses.push(\`\${sanitizeIdentifier(sortBy)} \${sortOrderValue}\`)
+    }
+    if (orderClauses.length > 0) {
+      sql += \` ORDER BY \${orderClauses.join(', ')}\`
+      if (search && search.rank) queryParams.push(...search.rankParams)
     }
     
     const limitValue = limit || perPage