@strav/search 0.3.20 → 0.3.22

package/src/drivers/postgres/engine/typo_expander.ts

@@ -0,0 +1,131 @@
+import type { SQL } from 'bun'
+import { termsTableName } from '../storage/identifiers.ts'
+import type { ResolvedTypoTolerance } from '../types.ts'
+
+/** Tokeniser used for terms-dict maintenance. Mirrors embedded driver. */
+export function tokenize(text: string): string[] {
+  if (!text) return []
+  const tokens: string[] = []
+  for (const raw of text.toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+    if (raw.length >= 2) tokens.push(raw)
+  }
+  return tokens
+}
+
+/** Increment per-document term frequencies (counting unique tokens per doc). */
+export async function recordTerms(
+  sql: SQL,
+  schema: string,
+  index: string,
+  text: string
+): Promise<void> {
+  const unique = Array.from(new Set(tokenize(text)))
+  if (unique.length === 0) return
+
+  const placeholders = unique.map((_, i) => `($${i + 1})`).join(', ')
+  await sql.unsafe(
+    `INSERT INTO ${termsTableName(schema, index)} (term) VALUES ${placeholders} ` +
+      `ON CONFLICT (term) DO UPDATE SET doc_freq = ${termsTableName(schema, index)}.doc_freq + 1`,
+    unique
+  )
+}
+
+/** Decrement; purge rows that drop to zero. */
+export async function unrecordTerms(
+  sql: SQL,
+  schema: string,
+  index: string,
+  text: string
+): Promise<void> {
+  const unique = Array.from(new Set(tokenize(text)))
+  if (unique.length === 0) return
+
+  const placeholders = unique.map((_, i) => `$${i + 1}`).join(', ')
+  await sql.unsafe(
+    `UPDATE ${termsTableName(schema, index)} SET doc_freq = doc_freq - 1 WHERE term IN (${placeholders})`,
+    unique
+  )
+  await sql.unsafe(`DELETE FROM ${termsTableName(schema, index)} WHERE doc_freq <= 0`)
+}
+
+/**
+ * Look up Levenshtein-near terms via pg_trgm prefilter. When fuzzystrmatch is
+ * available we re-rank with bounded Levenshtein for precision (trigram on
+ * short tokens is statistically noisy).
+ */
+export async function expandTokens(
+  sql: SQL,
+  schema: string,
+  index: string,
+  tokens: string[],
+  settings: ResolvedTypoTolerance,
+  hasFuzzystrmatch: boolean,
+  maxCandidates = 8
+): Promise<Map<string, string[]>> {
+  const out = new Map<string, string[]>()
+  if (!settings.enabled || tokens.length === 0) return out
+
+  for (const token of tokens) {
+    if (token.length < settings.minTokenLength) continue
+
+    // pg_trgm uses a per-session similarity threshold. We set it transactionally
+    // via the WHERE clause comparison instead, so caller's session isn't touched.
+    const rows = (await sql.unsafe(
+      hasFuzzystrmatch
+        ? `WITH cands AS (
+             SELECT term FROM ${termsTableName(schema, index)}
+             WHERE similarity(term, $1) >= $2 AND term <> $1
+             ORDER BY similarity(term, $1) DESC
+             LIMIT 32
+           )
+           SELECT term FROM cands
+           WHERE levenshtein(term, $1) <= $3
+           LIMIT $4`
+        : `SELECT term FROM ${termsTableName(schema, index)}
+             WHERE similarity(term, $1) >= $2 AND term <> $1
+             ORDER BY similarity(term, $1) DESC
+             LIMIT $3`,
+      hasFuzzystrmatch
+        ? [token, settings.similarity, settings.maxDistance, maxCandidates]
+        : [token, settings.similarity, maxCandidates]
+    )) as Array<{ term: string }>
+
+    if (rows.length > 0) out.set(token, rows.map(r => r.term))
+  }
+
+  return out
+}
+
+/** Resolve user-provided typo tolerance settings into concrete numbers. */
+export function resolveTypoTolerance(
+  setting:
+    | 'off'
+    | 'auto'
+    | { minTokenLength?: number; maxDistance?: number; similarity?: number }
+    | undefined
+): ResolvedTypoTolerance {
+  if (setting === 'off') {
+    return { enabled: false, minTokenLength: 4, maxDistance: 1, similarity: 0.4 }
+  }
+  if (setting === undefined || setting === 'auto') {
+    return { enabled: true, minTokenLength: 4, maxDistance: 1, similarity: 0.4 }
+  }
+  return {
+    enabled: true,
+    minTokenLength: setting.minTokenLength ?? 4,
+    maxDistance: setting.maxDistance ?? 1,
+    similarity: setting.similarity ?? 0.4,
+  }
+}
+
+/** Detect whether fuzzystrmatch.levenshtein is available. */
+export async function hasFuzzystrmatch(sql: SQL): Promise<boolean> {
+  try {
+    const rows = (await sql.unsafe(
+      `SELECT 1 FROM pg_proc WHERE proname = 'levenshtein' LIMIT 1`
+    )) as Array<Record<string, unknown>>
+    return rows.length > 0
+  } catch {
+    return false
+  }
+}

package/src/drivers/postgres/errors.ts

@@ -0,0 +1,33 @@
+import { SearchError } from '../../errors.ts'
+
+export class PostgresFtsError extends SearchError {}
+
+export class MissingExtensionError extends PostgresFtsError {
+  constructor(extension: string) {
+    super(
+      `Postgres extension "${extension}" is required by the postgres-fts driver. ` +
+        `Run \`CREATE EXTENSION ${extension}\` as a superuser, or set typoTolerance: 'off' if you can't.`
+    )
+  }
+}
+
+export class RebuildRequiredError extends PostgresFtsError {
+  constructor(message: string) {
+    super(message)
+  }
+}
+
+export class UnsupportedFilterError extends PostgresFtsError {
+  constructor(message: string) {
+    super(`Postgres-fts driver filter is unsupported: ${message}`)
+  }
+}
+
+export class MissingConnectionError extends PostgresFtsError {
+  constructor() {
+    super(
+      'PostgresFtsDriver has no Postgres connection. ' +
+        'Pass `connection` in the driver config, or bootstrap @strav/database first so Database.raw is available.'
+    )
+  }
+}

package/src/drivers/postgres/filters/filter_compiler.ts

@@ -0,0 +1,138 @@
+import { UnsupportedFilterError } from '../errors.ts'
+import { quoteIdent } from '../storage/identifiers.ts'
+
+export interface CompiledFilter {
+  /** SQL fragment to splice into a WHERE clause (no leading 'WHERE'). Empty if no filter. */
+  sql: string
+  /** Bound parameters in the order their `$N` placeholders appear. */
+  params: unknown[]
+  /** Number of params already used (caller offsets later placeholders). */
+  paramCount: number
+}
+
+const OPERATORS = new Set(['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'nin'])
+
+/**
+ * Compile a filter object into a parameterized SQL WHERE fragment.
+ * Mirrors the embedded driver's contract — same operator set, same shape.
+ *
+ * Placeholder numbering starts at `startAt + 1` ($N+1, $N+2, ...) so callers
+ * can compose with their own bindings.
+ */
+export function compileFilter(
+  filter: Record<string, unknown> | string | undefined,
+  filterableAttributes: ReadonlySet<string>,
+  startAt = 0
+): CompiledFilter {
+  if (!filter) return { sql: '', params: [], paramCount: 0 }
+
+  if (typeof filter === 'string') {
+    throw new UnsupportedFilterError(
+      'Raw string filters are not supported by the postgres-fts driver. ' +
+        'Pass an object like `{ status: "published" }` instead.'
+    )
+  }
+
+  const clauses: string[] = []
+  const params: unknown[] = []
+  let cursor = startAt
+
+  const ph = () => `$${++cursor}`
+
+  for (const [key, value] of Object.entries(filter)) {
+    if (value === undefined) continue
+    if (!filterableAttributes.has(key)) {
+      throw new UnsupportedFilterError(
+        `Field "${key}" is not in filterableAttributes. Add it to the index settings before filtering on it.`
+      )
+    }
+
+    const col = quoteIdent(key)
+
+    if (value === null) {
+      clauses.push(`${col} IS NULL`)
+      continue
+    }
+
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        clauses.push('1 = 0')
+      } else {
+        const placeholders = value.map(() => ph()).join(', ')
+        clauses.push(`${col} IN (${placeholders})`)
+        params.push(...value.map(coerce))
+      }
+      continue
+    }
+
+    if (isOperatorObject(value)) {
+      for (const [op, opValue] of Object.entries(value)) {
+        const compiled = compileOperator(col, op, opValue, ph)
+        clauses.push(compiled.sql)
+        params.push(...compiled.params)
+      }
+      continue
+    }
+
+    if (isPrimitive(value)) {
+      clauses.push(`${col} = ${ph()}`)
+      params.push(coerce(value))
+      continue
+    }
+
+    throw new UnsupportedFilterError(
+      `Unsupported filter value for key "${key}": ${JSON.stringify(value)}`
+    )
+  }
+
+  return { sql: clauses.join(' AND '), params, paramCount: cursor - startAt }
+}
+
+function compileOperator(
+  col: string,
+  op: string,
+  value: unknown,
+  ph: () => string
+): { sql: string; params: unknown[] } {
+  switch (op) {
+    case 'eq':
+      return { sql: `${col} = ${ph()}`, params: [coerce(value)] }
+    case 'neq':
+      return { sql: `${col} <> ${ph()}`, params: [coerce(value)] }
+    case 'gt':
+      return { sql: `${col} > ${ph()}`, params: [coerce(value)] }
+    case 'gte':
+      return { sql: `${col} >= ${ph()}`, params: [coerce(value)] }
+    case 'lt':
+      return { sql: `${col} < ${ph()}`, params: [coerce(value)] }
+    case 'lte':
+      return { sql: `${col} <= ${ph()}`, params: [coerce(value)] }
+    case 'in': {
+      if (!Array.isArray(value) || value.length === 0) return { sql: '1 = 0', params: [] }
+      const placeholders = value.map(() => ph()).join(', ')
+      return { sql: `${col} IN (${placeholders})`, params: value.map(coerce) }
+    }
+    case 'nin': {
+      if (!Array.isArray(value) || value.length === 0) return { sql: '1 = 1', params: [] }
+      const placeholders = value.map(() => ph()).join(', ')
+      return { sql: `${col} NOT IN (${placeholders})`, params: value.map(coerce) }
+    }
+    default:
+      throw new UnsupportedFilterError(`Unknown operator "${op}"`)
+  }
+}
+
+function isOperatorObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false
+  return Object.keys(value).every(k => OPERATORS.has(k))
+}
+
+function isPrimitive(value: unknown): boolean {
+  return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+}
+
+function coerce(value: unknown): unknown {
+  if (value === null || value === undefined) return null
+  if (typeof value === 'boolean') return value ? 1 : 0
+  return value
+}

package/src/drivers/postgres/index.ts

@@ -0,0 +1,14 @@
+export { PostgresFtsDriver } from './postgres_fts_driver.ts'
+export type {
+  PostgresFtsConfig,
+  TypoToleranceMode,
+  TypoToleranceSettings,
+  PgIndexSettings,
+} from './types.ts'
+export {
+  PostgresFtsError,
+  MissingExtensionError,
+  RebuildRequiredError,
+  UnsupportedFilterError,
+  MissingConnectionError,
+} from './errors.ts'

package/src/drivers/postgres/postgres_fts_driver.ts

@@ -0,0 +1,184 @@
+import type { SQL } from 'bun'
+import type { SearchEngine } from '../../search_engine.ts'
+import type {
+  SearchDocument,
+  SearchOptions,
+  SearchResult,
+  IndexSettings,
+  DriverConfig,
+} from '../../types.ts'
+import { PgEngine } from './engine/pg_engine.ts'
+import { ensureSchemaAndExtensions } from './engine/schema.ts'
+import { resolveTypoTolerance } from './engine/typo_expander.ts'
+import type { PostgresFtsConfig, PgIndexSettings, ResolvedTypoTolerance } from './types.ts'
+import { MissingConnectionError } from './errors.ts'
+
+const DEFAULT_SCHEMA = 'strav_search'
+const DEFAULT_LANGUAGE = 'english'
+const DEFAULT_WORK_MEM = '64MB'
+
+/**
+ * Postgres-backed full-text search driver. Implements the same `SearchEngine`
+ * interface as the embedded SQLite driver — drop-in swap by config.
+ *
+ * Sized for higher-volume workloads (1M-100M docs per index) using `tsvector`
+ * + GIN + `pg_trgm` for typo tolerance + `ts_headline` for snippets.
+ *
+ * Connection: pass `connection` (a Bun `SQL` instance) in the driver config,
+ * or rely on `Database.raw` from `@strav/database` (must be bootstrapped).
+ */
+export class PostgresFtsDriver implements SearchEngine {
+  readonly name = 'postgres-fts'
+
+  private readonly config: PostgresFtsConfig
+  private readonly schemaName: string
+  private readonly defaultLanguage: string
+  private readonly typo: ResolvedTypoTolerance
+  private readonly ginFastUpdate: boolean
+  private readonly workMem: string | null
+  private readonly engines = new Map<string, PgEngine>()
+  private readonly pendingSettings = new Map<string, PgIndexSettings>()
+  private bootstrapped: Promise<void> | null = null
+  private resolvedSql: SQL | null = null
+
+  constructor(config: DriverConfig) {
+    this.config = (config ?? {}) as PostgresFtsConfig
+    this.schemaName = this.config.schema ?? DEFAULT_SCHEMA
+    this.defaultLanguage = this.config.language ?? DEFAULT_LANGUAGE
+    this.typo = resolveTypoTolerance(this.config.typoTolerance)
+    this.ginFastUpdate = this.config.gin?.fastupdate ?? false
+    this.workMem =
+      this.config.workMem === null
+        ? null
+        : (this.config.workMem ?? DEFAULT_WORK_MEM)
+  }
+
+  // ── Document operations ──────────────────────────────────────────────────
+
+  async upsert(
+    index: string,
+    id: string | number,
+    document: Record<string, unknown>
+  ): Promise<void> {
+    await (await this.engineFor(index)).upsert(id, document)
+  }
+
+  async upsertMany(index: string, documents: SearchDocument[]): Promise<void> {
+    await (await this.engineFor(index)).upsertMany(documents)
+  }
+
+  async delete(index: string, id: string | number): Promise<void> {
+    await (await this.engineFor(index)).delete(id)
+  }
+
+  async deleteMany(index: string, ids: Array<string | number>): Promise<void> {
+    await (await this.engineFor(index)).deleteMany(ids)
+  }
+
+  // ── Index operations ─────────────────────────────────────────────────────
+
+  async flush(index: string): Promise<void> {
+    await (await this.engineFor(index)).flush()
+  }
+
+  async deleteIndex(index: string): Promise<void> {
+    const engine = this.engines.get(index)
+    if (engine) {
+      await engine.drop()
+      this.engines.delete(index)
+    } else {
+      // Drop directly without instantiating an engine.
+      const sql = this.resolveSql()
+      const { dropIndex } = await import('./engine/schema.ts')
+      await dropIndex(sql, this.schemaName, index)
+    }
+    this.pendingSettings.delete(index)
+  }
+
+  async createIndex(index: string, options?: IndexSettings): Promise<void> {
+    if (options) this.pendingSettings.set(index, options as PgIndexSettings)
+    const engine = await this.engineFor(index)
+    await engine.ensure()
+  }
+
+  // ── Search ───────────────────────────────────────────────────────────────
+
+  async search(index: string, query: string, options?: SearchOptions): Promise<SearchResult> {
+    return (await this.engineFor(index)).search(query, options)
+  }
+
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+
+  /** Run REINDEX on every open index, or just one if specified. */
+  async optimize(index?: string): Promise<void> {
+    if (index) {
+      await (await this.engineFor(index)).optimize()
+      return
+    }
+    for (const engine of this.engines.values()) await engine.optimize()
+  }
+
+  /**
+   * Rebuild a single index's `fts` column in place. Use after changing
+   * `searchableAttributes` or weights — without it, existing rows keep the
+   * old fts values.
+   */
+  async rebuild(
+    index: string,
+    options?: { reindex?: boolean; pauseMs?: number; onProgress?: (done: number, total: number) => void }
+  ): Promise<{ tier: 1 | 2; rows: number; elapsedMs: number }> {
+    return (await this.engineFor(index)).rebuild(options)
+  }
+
+  // ── Internals ────────────────────────────────────────────────────────────
+
+  private async engineFor(index: string): Promise<PgEngine> {
+    let engine = this.engines.get(index)
+    if (engine) return engine
+
+    await this.bootstrap()
+    const settings = this.pendingSettings.get(index)
+    engine = new PgEngine({
+      sql: this.resolveSql(),
+      schema: this.schemaName,
+      index,
+      language: settings?.language ?? this.defaultLanguage,
+      typoTolerance: this.typo,
+      ginFastUpdate: this.ginFastUpdate,
+      workMem: this.workMem,
+      settings,
+    })
+    this.engines.set(index, engine)
+    this.pendingSettings.delete(index)
+    return engine
+  }
+
+  /** Resolve the SQL connection (config.connection or Database.raw fallback). */
+  private resolveSql(): SQL {
+    if (this.resolvedSql) return this.resolvedSql
+    if (this.config.connection) {
+      this.resolvedSql = this.config.connection
+      return this.resolvedSql
+    }
+    try {
+      // Lazy require to avoid a hard dep at import time.
+      const databaseModule = require('@strav/database')
+      const Database = databaseModule.default ?? databaseModule.Database
+      this.resolvedSql = Database.raw as SQL
+      return this.resolvedSql
+    } catch {
+      throw new MissingConnectionError()
+    }
+  }
+
+  /** Idempotent: ensure schema + extensions exist, once per driver. */
+  private bootstrap(): Promise<void> {
+    if (this.bootstrapped) return this.bootstrapped
+    this.bootstrapped = ensureSchemaAndExtensions(
+      this.resolveSql(),
+      this.schemaName,
+      this.typo
+    )
+    return this.bootstrapped
+  }
+}

package/src/drivers/postgres/rebuild/rebuild_inplace.ts

@@ -0,0 +1,113 @@
+import type { SQL } from 'bun'
+import type { FieldRegistry } from '../engine/field_registry.ts'
+import { indexTableName, quoteLiteral, quoteIdent } from '../storage/identifiers.ts'
+import { RebuildRequiredError } from '../errors.ts'
+
+/** Tier boundaries for rebuild strategy selection. */
+const TIER1_MAX = 100_000
+const TIER2_MAX = 10_000_000
+
+/** Batch size for tier-2 batched UPDATE. */
+const BATCH_SIZE = 5_000
+
+export interface RebuildOptions {
+  /** If true, run REINDEX on the GIN index after the rebuild. Default true. */
+  reindex?: boolean
+  /** Per-batch sleep in milliseconds (tier 2 only). Default 50. */
+  pauseMs?: number
+  /** Optional progress callback fired after each batch. */
+  onProgress?: (done: number, total: number) => void
+}
+
+/**
+ * Rebuild an index's `fts` column in place using the current registry's
+ * language + weight scheme. Picks tier by row count:
+ * - < 100k → single UPDATE
+ * - 100k-10M → batched UPDATE with pauses
+ * - > 10M → RebuildRequiredError (defer to v1.1 swap strategy)
+ */
+export async function rebuildInPlace(
+  sql: SQL,
+  schema: string,
+  index: string,
+  registry: FieldRegistry,
+  options: RebuildOptions = {}
+): Promise<{ tier: 1 | 2; rows: number; elapsedMs: number }> {
+  const reindex = options.reindex ?? true
+  const pauseMs = options.pauseMs ?? 50
+  const table = indexTableName(schema, index)
+  const start = performance.now()
+
+  const countRows = (await sql.unsafe(
+    `SELECT COUNT(*)::bigint AS n FROM ${table}`
+  )) as Array<{ n: string | number }>
+  const total = Number(countRows[0]?.n ?? 0)
+
+  if (total > TIER2_MAX) {
+    throw new RebuildRequiredError(
+      `Index "${index}" has ${total} rows (>${TIER2_MAX}). ` +
+        `In-place / batched rebuild is unsafe at this scale. ` +
+        `Use the v1.1 dual-table swap strategy (not yet shipped).`
+    )
+  }
+
+  const ftsExpr = buildSetFtsExpression(registry)
+
+  if (total <= TIER1_MAX) {
+    await sql.unsafe(`UPDATE ${table} SET fts = ${ftsExpr}`)
+    if (reindex) await reindexGin(sql, schema, index)
+    return { tier: 1, rows: total, elapsedMs: Math.round(performance.now() - start) }
+  }
+
+  // Tier 2: batched update keyed by id, with pauses for autovacuum.
+  let cursor: string | null = null
+  let done = 0
+
+  while (true) {
+    const where = cursor === null ? '' : `WHERE id > $1`
+    const params = cursor === null ? [] : [cursor]
+    const batch = (await sql.unsafe(
+      `SELECT id FROM ${table} ${where} ORDER BY id LIMIT ${BATCH_SIZE}`,
+      params
+    )) as Array<{ id: string }>
+    if (batch.length === 0) break
+
+    const ids = batch.map(r => r.id)
+    const placeholders = ids.map((_, i) => `$${i + 1}`).join(', ')
+    await sql.unsafe(
+      `UPDATE ${table} SET fts = ${ftsExpr} WHERE id IN (${placeholders})`,
+      ids
+    )
+
+    done += batch.length
+    cursor = ids[ids.length - 1]!
+    options.onProgress?.(done, total)
+    if (pauseMs > 0) await new Promise(r => setTimeout(r, pauseMs))
+  }
+
+  if (reindex) await reindexGin(sql, schema, index)
+  return { tier: 2, rows: total, elapsedMs: Math.round(performance.now() - start) }
+}
+
+function buildSetFtsExpression(registry: FieldRegistry): string {
+  const lang = `${quoteLiteral(registry.language)}::regconfig`
+  if (registry.usesDefaultTextColumn) {
+    return (
+      `setweight(to_tsvector(${lang}, ` +
+      `(SELECT coalesce(string_agg(value, ' '), '') FROM jsonb_each_text(doc))), 'A')`
+    )
+  }
+  return registry.searchable
+    .map(attr => {
+      const weight = registry.weights.get(attr)!
+      return (
+        `setweight(to_tsvector(${lang}, coalesce(doc->>${quoteLiteral(attr)}, '')), '${weight}')`
+      )
+    })
+    .join(' || ')
+}
+
+async function reindexGin(sql: SQL, schema: string, index: string): Promise<void> {
+  const ginName = `${quoteIdent(schema)}.${quoteIdent(`search_${index}_fts_gin`)}`
+  await sql.unsafe(`REINDEX INDEX ${ginName}`)
+}

package/src/drivers/postgres/storage/identifiers.ts

@@ -0,0 +1,46 @@
+import { PostgresFtsError } from '../errors.ts'
+
+const PG_IDENT_MAX = 63
+
+/**
+ * Quote a Postgres identifier (schema, table, column). Throws on identifiers
+ * containing NUL or exceeding the 63-byte name limit.
+ */
+export function quoteIdent(name: string): string {
+  if (name.includes('\0')) throw new PostgresFtsError(`Invalid identifier: contains NUL byte.`)
+  if (Buffer.byteLength(name, 'utf8') > PG_IDENT_MAX) {
+    throw new PostgresFtsError(
+      `Identifier "${name}" exceeds Postgres' ${PG_IDENT_MAX}-byte limit.`
+    )
+  }
+  return `"${name.replace(/"/g, '""')}"`
+}
+
+/** Quote a single-quoted SQL string literal (used inside DDL options). */
+export function quoteLiteral(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`
+}
+
+/** Build the schema-qualified table name for a search index. */
+export function indexTableName(schema: string, index: string): string {
+  return `${quoteIdent(schema)}.${quoteIdent(`search_${index}`)}`
+}
+
+/** Terms-dictionary table name for a given index. */
+export function termsTableName(schema: string, index: string): string {
+  return `${quoteIdent(schema)}.${quoteIdent(`search_${index}_terms`)}`
+}
+
+/** Meta table — single shared table; rows keyed by (index_name, key). */
+export function metaTableName(schema: string): string {
+  return `${quoteIdent(schema)}.${quoteIdent('_meta')}`
+}
+
+/** Bare (unquoted) tablename — useful for pg_class lookups. */
+export function bareIndexTable(index: string): string {
+  return `search_${index}`
+}
+
+export function bareTermsTable(index: string): string {
+  return `search_${index}_terms`
+}