@meith/db 0.31.0 → 0.32.0

package/src/post-writes.ts

@@ -17,7 +17,12 @@ import type {
 
 import type { Database } from './client'
 import { resultRows } from './result-rows'
-import { indexedSubjectSql, SEARCH_DOCUMENT_VERSION, searchVectorSql } from './search-repo'
+import {
+  indexedSubjectSql,
+  readSearchConfig,
+  SEARCH_DOCUMENT_VERSION,
+  searchVectorSql,
+} from './search-repo'
 import { logModeratorAction } from './thread-counters'
 import { applyVisibilityChangeCounters } from './visibility-counters'
 import { readBoardVocabulary } from './vocabulary-repo'
@@ -116,6 +121,7 @@ export class PostgresPostWriteRepository implements PostWriteRepository {
       { source: 'post', viewer: authorRef(record.editedByUserId), postId: record.postId },
       vocabularyOptions(vocabulary),
     )
+    const searchConfig = await readSearchConfig(this.db)
 
     await this.db.transaction(async (tx) => {
       await tx.execute(sql`
@@ -148,7 +154,7 @@ export class PostgresPostWriteRepository implements PostWriteRepository {
                 * edited opening post lost the title an edit is supposed to
                 * preserve. The alias is why the statement names "posts p".
                 */
-               search_vector = ${searchVectorSql(indexedSubjectSql(sql`p`), sql`${record.message}`)},
+               search_vector = ${searchVectorSql(searchConfig, indexedSubjectSql(sql`p`), sql`${record.message}`)},
                search_version = ${SEARCH_DOCUMENT_VERSION},
                render_version = ${body.version},
                vocab_version = ${vocabulary.revision},
@@ -187,6 +193,16 @@ export class PostgresPostWriteRepository implements PostWriteRepository {
           record.editedAt,
         )
       }
+
+      if (record.toVisibility === 'visible') {
+        await tx.execute(sql`
+          insert into outbox (topic, payload)
+          values (
+            'post.edited',
+            ${JSON.stringify({ postId: record.postId, threadId: record.threadId })}::jsonb
+          )
+        `)
+      }
     })
   }
 
@@ -221,6 +237,20 @@ export class PostgresPostWriteRepository implements PostWriteRepository {
         )
       }
 
+      if (record.to === 'deleted' && record.from === 'visible') {
+        await tx.execute(sql`
+          insert into outbox (topic, payload)
+          values (
+            'post.deleted',
+            ${JSON.stringify({
+              postId: record.postId,
+              threadId: record.threadId,
+              forumId: record.forumId,
+            })}::jsonb
+          )
+        `)
+      }
+
       return true
     })
   }

package/src/presence-repo.ts

@@ -4,7 +4,7 @@ import type { ContentScope } from '@meith/core'
 
 import type { Database } from './client'
 import { resultRows } from './result-rows'
-import { toDate } from './row-values'
+import { toDate, toNullableDate } from './row-values'
 import { inAudience } from './thread-audience'
 import { visibleIn } from './visibility'
 
@@ -42,6 +42,12 @@ export interface OnlineRecord {
   readonly at: Date | null
 }
 
+export interface MemberPresence {
+  readonly userId: number
+  readonly lastActiveAt: Date | null
+  readonly invisible: boolean
+}
+
 export class PostgresPresenceRepository {
   constructor(private readonly db: Database) {}
 
@@ -118,6 +124,28 @@ export class PostgresPresenceRepository {
     }
   }
 
+  async lastActiveFor(userIds: readonly number[]): Promise<readonly MemberPresence[]> {
+    if (userIds.length === 0) return []
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, last_active_at, invisible
+          from users
+         where id in (${sql.join(
+           userIds.map((id) => sql`${id}`),
+           sql`, `,
+         )})
+           and state = 'active'
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      userId: Number(row.id),
+      lastActiveAt: toNullableDate(row.last_active_at),
+      invisible: row.invisible === true,
+    }))
+  }
+
   async touchGuest(input: {
     readonly tokenHash: string
     readonly location: {

package/src/read-state-repo.ts

@@ -1,7 +1,7 @@
 import { and, eq, gt, isNull, or, sql } from 'drizzle-orm'
 
 import { PUBLIC_CONTENT } from '@meith/core'
-import type { ReadState, ReadStateRepository } from '@meith/threads'
+import type { ReadState, ReadStateRepository, ThreadReadMarker } from '@meith/threads'
 
 import type { Database } from './client'
 import { forumsRead, threads, threadsRead } from './schema'
@@ -55,6 +55,26 @@ export class PostgresReadStateRepository implements ReadStateRepository {
     }
   }
 
+  async markerFor(userId: number, threadId: number, forumId: number): Promise<ThreadReadMarker> {
+    const [threadRows, forumRows] = await Promise.all([
+      this.db
+        .select({ lastReadPostId: threadsRead.lastReadPostId })
+        .from(threadsRead)
+        .where(and(eq(threadsRead.userId, userId), eq(threadsRead.threadId, threadId)))
+        .limit(1),
+      this.db
+        .select({ readAt: forumsRead.readAt })
+        .from(forumsRead)
+        .where(and(eq(forumsRead.userId, userId), eq(forumsRead.forumId, forumId)))
+        .limit(1),
+    ])
+
+    return {
+      lastReadPostId: threadRows[0]?.lastReadPostId ?? null,
+      forumReadAt: forumRows[0]?.readAt ?? null,
+    }
+  }
+
   async markForumsRead(userId: number, forumIds: readonly number[], at: Date): Promise<void> {
     if (forumIds.length === 0) return
     await this.db

package/src/report-repo.ts

@@ -3,6 +3,7 @@ import { sql } from 'drizzle-orm'
 import { PUBLIC_CONTENT } from '@meith/core'
 import type {
   NewReport,
+  ReportCategory,
   ReportEvent,
   ReportPage,
   ReportRepository,
@@ -17,8 +18,9 @@ import { decodeCursor, encodeCursor } from './cursor'
 import { resultRows } from './result-rows'
 import { threads } from './schema'
 import { idList } from './sql-lists'
-import { logModeratorAction } from './thread-counters'
-import { visibleIn } from './visibility'
+import { type CounterTx, logModeratorAction } from './thread-counters'
+import { PENDING_APPROVAL, VISIBLE, visibleIn } from './visibility'
+import { applyVisibilityChangeCounters } from './visibility-counters'
 
 interface RawReport {
   id: number
@@ -29,6 +31,7 @@ interface RawReport {
   target_label: string
   reporter_user_id: number | null
   reporter_username: string | null
+  category: ReportCategory
   reason: string
   status: ReportRow['status']
   assigned_to_user_id: number | null
@@ -46,6 +49,7 @@ function toReport(row: RawReport): ReportRow {
     targetLabel: row.target_label,
     reporterUserId: row.reporter_user_id === null ? null : Number(row.reporter_user_id),
     reporterUsername: row.reporter_username,
+    category: row.category,
     reason: row.reason,
     status: row.status,
     assignedToUserId: row.assigned_to_user_id === null ? null : Number(row.assigned_to_user_id),
@@ -57,7 +61,7 @@ function toReport(row: RawReport): ReportRow {
 const SELECT_REPORT = sql`
   select r.id, r.target_kind, r.target_id, r.forum_id, r.thread_id, r.target_label,
          r.reporter_user_id, reporter.username as reporter_username,
-         r.reason, r.status, r.assigned_to_user_id,
+         r.category, r.reason, r.status, r.assigned_to_user_id,
          assignee.username as assigned_username, r.created_at
     from reports r
     left join users reporter on reporter.id = r.reporter_user_id
@@ -174,11 +178,11 @@ export class PostgresReportRepository implements ReportRepository {
         await tx.execute(sql`
           insert into reports
             (target_kind, target_id, forum_id, thread_id, target_label,
-             reporter_user_id, reason, status, created_at, updated_at)
+             reporter_user_id, category, reason, status, created_at, updated_at)
           values
             (${report.target.kind}, ${report.target.id}, ${report.target.forumId},
              ${report.target.threadId}, ${report.target.label},
-             ${report.reporterUserId}, ${report.reason}, 'open',
+             ${report.reporterUserId}, ${report.category}, ${report.reason}, 'open',
              ${report.at}, ${report.at})
           on conflict do nothing
           returning id
@@ -192,21 +196,159 @@ export class PostgresReportRepository implements ReportRepository {
         insert into report_events (report_id, actor_user_id, kind, created_at)
         values (${row.id}, ${report.reporterUserId}, 'opened', ${report.at})
       `)
+
+      await tx.execute(sql`
+        insert into outbox (topic, payload)
+        values (
+          'report.created',
+          ${JSON.stringify({
+            reportId: Number(row.id),
+            targetKind: report.target.kind,
+            targetId: report.target.id,
+            reporterId: report.reporterUserId,
+          })}::jsonb
+        )
+      `)
+
+      await this.autoHold(tx, report)
+
       return Number(row.id)
     })
   }
 
+  private async autoHold(tx: CounterTx, report: NewReport): Promise<void> {
+    if (report.flagThreshold <= 0 || report.target.kind !== 'post') return
+
+    const counted = resultRows(
+      await tx.execute(sql`
+        with last_hold as (
+          select max(created_at) as at
+            from admin_log
+           where action = 'post.autohold'
+             and (detail->>'postId')::int = ${report.target.id}
+        )
+        select count(distinct r.reporter_user_id)::int as reporters
+          from reports r, last_hold
+         where r.status = 'open'
+           and r.target_kind = 'post'
+           and r.target_id = ${report.target.id}
+           and r.reporter_user_id is not null
+           and (last_hold.at is null or r.created_at > last_hold.at)
+      `),
+    ) as Array<{ reporters: number }>
+    if (Number(counted[0]?.reporters ?? 0) < report.flagThreshold) return
+
+    const found = resultRows(
+      await tx.execute(sql`
+        select thread_id, forum_id, is_first_post from posts where id = ${report.target.id}
+      `),
+    ) as Array<{ thread_id: number; forum_id: number; is_first_post: boolean }>
+    const post = found[0]
+    if (!post) return
+
+    const threadId = Number(post.thread_id)
+    const forumId = Number(post.forum_id)
+
+    const held = post.is_first_post
+      ? await this.holdThread(tx, threadId, forumId)
+      : await this.holdReply(tx, report.target.id, threadId, forumId)
+    if (held === null) return
+
+    await tx.execute(sql`
+      insert into admin_log (user_id, action, detail, created_at)
+      values (
+        null,
+        'post.autohold',
+        ${JSON.stringify({
+          postId: report.target.id,
+          threadId,
+          forumId,
+          forumIds: [forumId],
+          heldPostIds: held,
+        })}::jsonb,
+        ${report.at}
+      )
+    `)
+  }
+
+  private async holdReply(
+    tx: CounterTx,
+    postId: number,
+    threadId: number,
+    forumId: number,
+  ): Promise<readonly number[] | null> {
+    const moved = resultRows(
+      await tx.execute(sql`
+        update posts set visibility = ${PENDING_APPROVAL}
+         where id = ${postId} and visibility = ${VISIBLE}
+         returning author_user_id
+      `),
+    ) as Array<{ author_user_id: number | null }>
+    const row = moved[0]
+    if (!row) return null
+
+    await applyVisibilityChangeCounters(tx, {
+      postId,
+      threadId,
+      forumId,
+      authorId: row.author_user_id === null ? null : Number(row.author_user_id),
+      isFirstPost: false,
+      delta: -1,
+    })
+    return [postId]
+  }
+
+  private async holdThread(
+    tx: CounterTx,
+    threadId: number,
+    forumId: number,
+  ): Promise<readonly number[] | null> {
+    const movedThread = resultRows(
+      await tx.execute(sql`
+        update threads set visibility = ${PENDING_APPROVAL}, updated_at = now()
+         where id = ${threadId} and visibility = ${VISIBLE}
+         returning id
+      `),
+    ) as Array<{ id: number }>
+    if (movedThread.length === 0) return null
+
+    const posts = resultRows(
+      await tx.execute(sql`
+        update posts set visibility = ${PENDING_APPROVAL}
+         where thread_id = ${threadId} and visibility = ${VISIBLE}
+         returning id, author_user_id, is_first_post
+      `),
+    ) as Array<{ id: number; author_user_id: number | null; is_first_post: boolean }>
+
+    for (const post of posts) {
+      await applyVisibilityChangeCounters(tx, {
+        postId: Number(post.id),
+        threadId,
+        forumId,
+        authorId: post.author_user_id === null ? null : Number(post.author_user_id),
+        isFirstPost: post.is_first_post === true,
+        delta: -1,
+      })
+    }
+    return posts.map((post) => Number(post.id))
+  }
+
   private scopePredicate(scope: ReportScope): ReturnType<typeof sql> {
     const byForum = sql`r.forum_id in ${idList(scope.forumIds)}`
     return scope.global ? sql`(${byForum} or r.forum_id is null)` : byForum
   }
 
+  private categoryPredicate(category: ReportCategory | undefined): ReturnType<typeof sql> {
+    return category === undefined ? sql`` : sql`and r.category = ${category}`
+  }
+
   async listOpen(
     scope: ReportScope,
     options: {
       readonly limit: number
       readonly after?: string
       readonly offset?: number
+      readonly category?: ReportCategory
     },
   ): Promise<ReportPage> {
     const cursor = options.after === undefined ? null : decodeCursor(options.after)
@@ -215,7 +357,8 @@ export class PostgresReportRepository implements ReportRepository {
     const rows = resultRows(
       await this.db.execute(sql`
         ${SELECT_REPORT}
-         where r.status = 'open' and ${this.scopePredicate(scope)} ${after}
+         where r.status = 'open' and ${this.scopePredicate(scope)}
+           ${this.categoryPredicate(options.category)} ${after}
          order by r.created_at, r.id
          limit ${options.limit + 1} offset ${options.offset ?? 0}
       `),
@@ -228,11 +371,12 @@ export class PostgresReportRepository implements ReportRepository {
       : { rows: page }
   }
 
-  async countOpen(scope: ReportScope): Promise<number> {
+  async countOpen(scope: ReportScope, category?: ReportCategory): Promise<number> {
     const rows = resultRows(
       await this.db.execute(sql`
         select count(*)::int as open from reports r
          where r.status = 'open' and ${this.scopePredicate(scope)}
+           ${this.categoryPredicate(category)}
       `),
     ) as Array<{ open: number }>
     return Number(rows[0]?.open ?? 0)

package/src/schema/content.ts

@@ -248,6 +248,9 @@ export type ReportTargetKind = (typeof REPORT_TARGET_KINDS)[number]
 export const REPORT_STATUSES = ['open', 'resolved', 'rejected'] as const
 export type ReportStatus = (typeof REPORT_STATUSES)[number]
 
+export const REPORT_CATEGORIES = ['spam', 'off_topic', 'abuse', 'other'] as const
+export type ReportCategory = (typeof REPORT_CATEGORIES)[number]
+
 export const reports = pgTable(
   'reports',
   {
@@ -256,6 +259,8 @@ export const reports = pgTable(
     targetKind: text('target_kind').notNull(),
     targetId: integer('target_id').notNull(),
 
+    category: text('category').notNull().default('other'),
+
     forumId: integer('forum_id').references(() => forums.id, {
       onDelete: 'set null',
     }),

package/src/schema/identity.ts

@@ -112,6 +112,9 @@ export const users = pgTable(
     emailVerifiedAt: timestamp('email_verified_at', { withTimezone: true }),
     massMailOptInAt: timestamp('mass_mail_opt_in_at', { withTimezone: true }),
 
+    boardDigestCadence: text('board_digest_cadence').notNull().default('weekly'),
+    boardDigestSentAt: timestamp('board_digest_sent_at', { withTimezone: true }),
+
     suspendedPostingUntil: timestamp('suspended_posting_until', { withTimezone: true }),
     moderatedPostingUntil: timestamp('moderated_posting_until', { withTimezone: true }),
 
@@ -121,6 +124,9 @@ export const users = pgTable(
     threadsPerPage: smallint('threads_per_page'),
     invisible: boolean('invisible').notNull().default(false),
 
+    autoWatchOwnThreads: text('auto_watch_own_threads').notNull().default('none'),
+    autoWatchRepliedThreads: text('auto_watch_replied_threads').notNull().default('none'),
+
     location: text('location'),
     website: text('website'),
     bio: text('bio'),
@@ -246,6 +252,27 @@ export const rememberTokens = pgTable(
   ],
 )
 
+export const feedTokens = pgTable(
+  'feed_tokens',
+  {
+    id: integer('id').primaryKey().generatedByDefaultAsIdentity(),
+
+    userId: integer('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+
+    lookup: text('lookup').notNull(),
+    secretHash: text('secret_hash').notNull(),
+
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    lastUsedAt: timestamp('last_used_at', { withTimezone: true }),
+  },
+  (t) => [
+    uniqueIndex('feed_tokens_user_key').on(t.userId),
+    uniqueIndex('feed_tokens_lookup_key').on(t.lookup),
+  ],
+)
+
 export const userIdentities = pgTable(
   'user_identities',
   {
@@ -570,7 +597,12 @@ export const notificationPreferences = pgTable(
     push: boolean('push'),
     updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
   },
-  (t) => [primaryKey({ name: 'notification_preferences_pkey', columns: [t.userId, t.kind] })],
+  (t) => [
+    primaryKey({ name: 'notification_preferences_pkey', columns: [t.userId, t.kind] }),
+    index('notification_preferences_kind_email_idx')
+      .on(t.kind, t.userId)
+      .where(sql`${t.email} = true`),
+  ],
 )
 
 export const pushSubscriptions = pgTable(

package/src/schema/platform.ts

@@ -122,6 +122,8 @@ export const tasks = pgTable('tasks', {
 
   intervalSeconds: integer('interval_seconds').notNull(),
 
+  schedule: text('schedule'),
+
   enabled: boolean('enabled').notNull().default(true),
 
   lastRunAt: timestamp('last_run_at', { withTimezone: true }),

package/src/search-repo.ts

@@ -10,13 +10,27 @@ import type {
   SearchScope,
   SearchSummary,
 } from '@meith/search'
+import { DEFAULT_SEARCH_LANGUAGE, SEARCH_LANGUAGES } from '@meith/settings'
 
 import type { Database } from './client'
 import { resultRows } from './result-rows'
 import { inAudience } from './thread-audience'
 import { visibleIn } from './visibility'
 
-const SEARCH_CONFIG = 'english'
+const SEARCH_LANGUAGE_SET: ReadonlySet<string> = new Set(SEARCH_LANGUAGES)
+
+export const DEFAULT_SEARCH_CONFIG: string = DEFAULT_SEARCH_LANGUAGE
+
+export function resolveSearchConfig(value: string | null | undefined): string {
+  return typeof value === 'string' && SEARCH_LANGUAGE_SET.has(value) ? value : DEFAULT_SEARCH_CONFIG
+}
+
+export async function readSearchConfig(db: Database): Promise<string> {
+  const rows = resultRows(
+    await db.execute(sql`select value from settings where key = 'search.language'`),
+  ) as Array<{ value: string }>
+  return resolveSearchConfig(rows[0]?.value)
+}
 
 export const SEARCH_WINDOW = 20_000
 
@@ -51,10 +65,10 @@ export function renderExcerptHtml(headline: string): string {
     .join('</b>')
 }
 
-export function searchVectorSql(subject: SQL | string, message: SQL | string): SQL {
+export function searchVectorSql(config: string, subject: SQL | string, message: SQL | string): SQL {
   return sql`
-    setweight(to_tsvector(${SEARCH_CONFIG}, coalesce(${subject}, '')), 'A') ||
-    setweight(to_tsvector(${SEARCH_CONFIG}, coalesce(${message}, '')), 'B')
+    setweight(to_tsvector(${config}, coalesce(${subject}, '')), 'A') ||
+    setweight(to_tsvector(${config}, coalesce(${message}, '')), 'B')
   `
 }
 
@@ -77,13 +91,20 @@ export interface ReindexResult {
 }
 
 export class PostgresSearchRepository {
-  constructor(private readonly db: Database) {}
+  private readonly config: string
+
+  constructor(
+    private readonly db: Database,
+    config: string = DEFAULT_SEARCH_CONFIG,
+  ) {
+    this.config = resolveSearchConfig(config)
+  }
 
   async search(query: SearchQuery, scope: SearchScope): Promise<SearchResults> {
-    const conditions = matchConditions(query, scope)
+    const conditions = matchConditions(this.config, query, scope)
     if (conditions === null) return { hits: [], nextCursor: null }
 
-    const rank = rankSql(query.terms)
+    const rank = rankSql(this.config, query.terms)
     const finalOrder = orderSql(query.sort)
 
     const selection = sql`
@@ -104,8 +125,8 @@ export class PostgresSearchRepository {
       await this.db.execute(sql`
         select post_id, thread_id, forum_id, thread_title, thread_slug,
                author_user_id, author_username, created_at, rank,
-               ts_headline(${SEARCH_CONFIG}, excerpt_source,
-                           websearch_to_tsquery(${SEARCH_CONFIG}, ${query.terms}),
+               ts_headline(${this.config}, excerpt_source,
+                           websearch_to_tsquery(${this.config}, ${query.terms}),
                            ${HEADLINE_OPTIONS}) as excerpt
           from ${candidates}
          order by ${finalOrder}
@@ -136,7 +157,7 @@ export class PostgresSearchRepository {
   }
 
   async summarize(query: SearchQuery, scope: SearchScope): Promise<SearchSummary> {
-    const conditions = matchConditions(query, scope)
+    const conditions = matchConditions(this.config, query, scope)
     if (conditions === null) return NOTHING
 
     const rows = resultRows(
@@ -204,10 +225,11 @@ export class PostgresSearchRepository {
   }
 
   async reindexChunk(afterPostId: number, limit: number): Promise<ReindexResult> {
+    const config = await readSearchConfig(this.db)
     const rows = resultRows(
       await this.db.execute(sql`
         update posts p
-           set search_vector = ${searchVectorSql(indexedSubjectSql(sql`p`), sql`p.message`)},
+           set search_vector = ${searchVectorSql(config, indexedSubjectSql(sql`p`), sql`p.message`)},
                search_version = ${SEARCH_DOCUMENT_VERSION}
          where p.id in (
            select id from posts
@@ -245,10 +267,19 @@ export class PostgresSearchRepository {
   async invalidateIndex(): Promise<void> {
     await this.db.execute(sql`update posts set search_vector = null, search_version = 0`)
   }
+
+  async markForReindex(): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(
+        sql`update posts set search_version = 0 where search_version <> 0 returning id`,
+      ),
+    ) as Array<{ id: number }>
+    return rows.length
+  }
 }
 
-function rankSql(terms: string): SQL {
-  return sql`ts_rank_cd(p.search_vector, websearch_to_tsquery(${SEARCH_CONFIG}, ${terms}))`
+function rankSql(config: string, terms: string): SQL {
+  return sql`ts_rank_cd(p.search_vector, websearch_to_tsquery(${config}, ${terms}))`
 }
 
 function excerptSourceSql(match: SearchQuery['match']): SQL {
@@ -263,7 +294,7 @@ function orderSql(sort: SearchQuery['sort']): SQL {
       : sql`post_id asc`
 }
 
-function matchConditions(query: SearchQuery, scope: SearchScope): SQL[] | null {
+function matchConditions(config: string, query: SearchQuery, scope: SearchScope): SQL[] | null {
   if (query.terms.trim() === '') return null
 
   const allowed =
@@ -279,7 +310,7 @@ function matchConditions(query: SearchQuery, scope: SearchScope): SQL[] | null {
       ...scope,
       forumIds: allowed,
     }),
-    sql`p.search_vector @@ websearch_to_tsquery(${SEARCH_CONFIG}, ${query.terms})`,
+    sql`p.search_vector @@ websearch_to_tsquery(${config}, ${query.terms})`,
   ]
 
   conditions.push(visibleIn(sql`p.visibility`, scope.content))
@@ -287,8 +318,8 @@ function matchConditions(query: SearchQuery, scope: SearchScope): SQL[] | null {
 
   if (query.match === 'titles') {
     conditions.push(
-      sql`to_tsvector(${SEARCH_CONFIG}, coalesce(${indexedSubjectSql(sql`p`)}, ''))
-          @@ websearch_to_tsquery(${SEARCH_CONFIG}, ${query.terms})`,
+      sql`to_tsvector(${config}, coalesce(${indexedSubjectSql(sql`p`)}, ''))
+          @@ websearch_to_tsquery(${config}, ${query.terms})`,
     )
   }