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

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()}
@@ -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
       }
     }
 

package/src/fetchers/turso.ts

@@ -5,6 +5,7 @@ import {
   generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import { generateSearchSqlHelpersCode, SQLITE_SEARCH_MATCH_SQL } from '../search-relevance'
 
 export const validateTursoConfig = (
   config: Record<string, unknown>
@@ -46,6 +47,7 @@ ${generateSafeJSONParseCode()}
 ${generateFilterTreeHelpersCode()}
 
 ${generateSearchEscapeHelpersCode()}
+${generateSearchSqlHelpersCode(SQLITE_SEARCH_MATCH_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

package/src/search-relevance.ts

@@ -0,0 +1,96 @@
+/**
+ * How a list's search box narrows and orders the rows of a generated route.
+ *
+ * Every typed word must appear in one of the searched columns, so "create
+ * form" finds "How to create a form". The matches are then ordered by where
+ * the words are: a row ranks by the first searched column, in the order the
+ * list searches them, that holds every word (a title match before a summary
+ * match before a body match), and a row whose words are spread over several
+ * columns comes after all of those. The list's own sort orders the rows
+ * within each of those groups.
+ */
+
+/** `searchWords(query)`: the typed words, lowercased, each once. */
+export const generateSearchWordsCode = (): string => `const searchWords = (query) => {
+  const words = []
+  String(query == null ? '' : query).toLowerCase().split(/\\s+/).forEach((word) => {
+    if (word && words.indexOf(word) === -1) words.push(word)
+  })
+  return words
+}`
+
+/**
+ * `buildSearchSql(query, columns, firstIndex)` for the SQL routes:
+ * `{ where, params, rank, rankParams, nextIndex }`, or null when there is
+ * nothing to search. `matchSql` is the dialect's case-insensitive substring
+ * test, `(column, placeholder) => sql`. With `firstIndex` the placeholders are
+ * numbered (`$n`) and each word's pattern is bound once, the rank reusing it;
+ * without it they are positional (`?`), every occurrence binds its own copy,
+ * and `rankParams` go after the parameters of the whole WHERE, as the ORDER BY
+ * comes after it. `rank` is '' with fewer than two columns.
+ *
+ * Uses `escapeLikePattern` and `sanitizeSearchIdentifier`
+ * (`generateSearchEscapeHelpersCode`).
+ */
+export const generateSearchSqlHelpersCode = (
+  matchSql: string
+): string => `${generateSearchWordsCode()}
+const searchMatchSql = ${matchSql}
+const buildSearchSql = (query, columns, firstIndex) => {
+  const words = searchWords(query)
+  const searched = []
+  ;(Array.isArray(columns) ? columns : []).forEach((column) => {
+    const name = sanitizeSearchIdentifier(column)
+    if (searched.indexOf(name) === -1) searched.push(name)
+  })
+  if (words.length === 0 || searched.length === 0) return null
+  const patterns = words.map((word) => '%' + escapeLikePattern(word) + '%')
+  const numbered = typeof firstIndex === 'number'
+  const params = numbered ? patterns.slice() : []
+  const rankParams = []
+  const placeholder = (wordIndex, bound) => {
+    if (numbered) return '$' + (firstIndex + wordIndex)
+    bound.push(patterns[wordIndex])
+    return '?'
+  }
+  const where = '(' + patterns.map((pattern, wordIndex) =>
+    '(' + searched.map((column) => searchMatchSql(column, placeholder(wordIndex, params))).join(' OR ') + ')'
+  ).join(' AND ') + ')'
+  const rank = searched.length < 2 ? '' : 'CASE ' + searched.map((column, position) =>
+    'WHEN ' + patterns.map((pattern, wordIndex) => searchMatchSql(column, placeholder(wordIndex, rankParams))).join(' AND ') + ' THEN ' + position
+  ).join(' ') + ' ELSE ' + searched.length + ' END'
+  return { where, params, rank, rankParams, nextIndex: numbered ? firstIndex + patterns.length : firstIndex }
+}`
+
+/**
+ * `rankBySearch(rows, query, columns, valueOf)` for the routes that search
+ * rows in memory: the same order as the SQL routes' rank, applied after the
+ * list's sort (a stable sort keeps it within each group) and before the page
+ * is cut.
+ */
+export const generateSearchRankHelperCode = (): string => `${generateSearchWordsCode()}
+const rankBySearch = (rows, query, columns, valueOf) => {
+  const words = searchWords(query)
+  if (!Array.isArray(columns) || columns.length < 2 || words.length === 0) return rows
+  const tierOf = (row) => {
+    for (let position = 0; position < columns.length; position++) {
+      const value = valueOf(row, columns[position])
+      const text = value === null || value === undefined ? '' : String(value).toLowerCase()
+      if (words.every((word) => text.includes(word))) return position
+    }
+    return columns.length
+  }
+  return rows
+    .map((row, index) => ({ row, index, tier: tierOf(row) }))
+    .sort((a, b) => a.tier - b.tier || a.index - b.index)
+    .map((entry) => entry.row)
+}`
+
+/** Each dialect's case-insensitive substring match, for `generateSearchSqlHelpersCode`. */
+export const PG_SEARCH_MATCH_SQL = `(column, placeholder) => '"' + column + '"::text ILIKE ' + placeholder + " ESCAPE '|'"`
+
+export const MYSQL_SEARCH_MATCH_SQL = `(column, placeholder) => 'LOWER(CAST(' + mysql.escapeId(column) + ' AS CHAR)) LIKE LOWER(' + placeholder + ") ESCAPE '|'"`
+
+export const MARIADB_SEARCH_MATCH_SQL = `(column, placeholder) => 'LOWER(CAST(\`' + column + '\` AS CHAR)) LIKE LOWER(' + placeholder + ") ESCAPE '|'"`
+
+export const SQLITE_SEARCH_MATCH_SQL = `(column, placeholder) => 'LOWER(CAST("' + column + '" AS TEXT)) LIKE LOWER(' + placeholder + ") ESCAPE '|'"`