從 100 行 Regex 到 Lucene Parser：複雜驗證邏輯的重構之路

(星冰樂 OR 那堤 OR 咖啡) AND (NOT (冷萃 OR 巧克力))

function validateKeywordsFormat(input: string): string | null {
  const trimmedInput = input.trim()

  // 檢查是否為空
  if (!trimmedInput) {
    return '請輸入關鍵字'
  }

  // 檢查括號是否配對
  let parenthesesCount = 0
  for (const char of trimmedInput) {
    if (char === '(') parenthesesCount++
    if (char === ')') parenthesesCount--
    if (parenthesesCount < 0) return '括號配對錯誤'
  }
  if (parenthesesCount !== 0) return '括號配對錯誤'

  // 檢查邏輯運算子格式（必須為大寫）
  if (/\b(?:and|not|or)\b/i.test(trimmedInput)) {
    return '邏輯運算子必須使用大寫：AND、NOT、OR'
  }

  // 檢查運算子前後是否有適當的空白
  if (/(?:^|\S)\b(?:AND|NOT|OR)\b(?:\S|$)/.test(trimmedInput)) {
    return '邏輯運算子前後必須有空白間隔'
  }

  // 檢查 AND/OR 不能緊接在左括號後面
  if (/\(\s*(?:AND|OR)\b/.test(trimmedInput)) {
    return 'AND/OR 運算子前面必須有運算元'
  }

  // ... 還有更多規則
}

輸入：(星冰樂 OR 那堤) AND (NOT (冷萃 OR 巧克力))
錯誤訊息：關鍵字中的邏輯運算子前後必須使用底線，例：hello_NOT_world

const operatorWithoutSpaces = /(?:^|\S)\b(?:AND|NOT|OR)\b(?:\S|$)/.test(trimmedInput)

const operatorWithoutSpaces = /(?:^|[^\s(])\b(?:AND|NOT|OR)\b(?:[^\s)]|$)/.test(trimmedInput)

if (/\(\s*(?:AND|OR)\b/.test(trimmedInput)) {
  return 'AND/OR 運算子前面必須有運算元'
}

import lucene from 'lucene'

const ast = lucene.parse('茶 AND 水')
console.log(ast)
// {
//   left: { field: '<implicit>', term: '茶', ... },
//   operator: 'AND',
//   right: { field: '<implicit>', term: '水', ... }
// }

function validateKeywordsFormat(input: string): string | null {
  const trimmed = input.trim()

  // 1. 空值檢查
  if (!trimmed) return '請輸入關鍵字'

  // 2. 預檢查（Parser 無法處理的規則）
  const preError = preValidateKeywords(trimmed)
  if (preError) return preError

  // 3. Parser 解析
  let ast: AST
  try {
    ast = lucene.parse(trimmed)
  } catch {
    return '關鍵字語法錯誤，請檢查括號配對與運算子使用'
  }

  // 4. AST 驗證（檢查不允許的特性）
  const featureError = checkDisallowedFeatures(ast)
  if (featureError) return featureError

  // 5. Term 格式檢查
  const terms = collectTerms(ast)
  for (const { term } of terms) {
    if (/_{2,}/.test(term)) return '請避免使用連續的底線'
    // ... 其他檢查
  }

  return null
}

function preValidateKeywords(input: string): string | null {
  // 小寫運算子（lucene 會把 'and' 當成關鍵字，不會報錯）
  if (/(?:^|\s)(?:and|or|not)(?:\s|$)/.test(input)) {
    return '邏輯運算子必須使用大寫：AND、NOT、OR'
  }

  // 運算子結尾（lucene 允許，但我們不允許）
  if (/\b(?:AND|OR|NOT)\s*$/.test(input)) {
    return '表達式不能以邏輯運算子結尾'
  }

  // 連續運算子
  if (/\b(?:AND|OR|NOT)\s+(?:AND|OR|NOT)\b/.test(input)) {
    return '不能有連續的邏輯運算子'
  }

  return null
}

function checkDisallowedFeatures(node: AST | Node): string | null {
  function traverse(n: unknown): string | null {
    if (!n || typeof n !== 'object') return null
    const obj = n as Record<string, unknown>

    // 檢查萬用字元（* 或 ?）
    if ('term' in obj && typeof obj.term === 'string') {
      if (obj.term.includes('*') || obj.term.includes('?')) {
        return '不支援萬用字元（* 或 ?）'
      }
    }

    // 檢查 AND/OR 開頭（AST 中會有 start 屬性）
    if ('start' in obj && (obj.start === 'AND' || obj.start === 'OR')) {
      return '表達式不能以 AND 或 OR 開頭'
    }

    // 遞迴檢查子節點
    const leftError = 'left' in obj ? traverse(obj.left) : null
    if (leftError) return leftError

    const rightError = 'right' in obj ? traverse(obj.right) : null
    if (rightError) return rightError

    return null
  }

  return traverse(node)
}