edit: works for simple cases

TODO:
tests
better error handling

Author: hp4k1h5

src/lib/structs.ts

@@ -15,15 +15,15 @@ export interface query {
   /**
    * either an array of @param term interfaces or a string to be parsed by `parseQuery()`
    * */
-  terms: term[] | string
+  terms: Term[] | string
   /**
    * the name(s) of the document key to search. @default "text"
    * */
   key?: string[] | string
   /**
    * a list of @filter interfaces. All filters are implicitly AND'ed together.
    * */
-  filters?: filter[]
+  filters?: Filter[]
 }
 
 /**
@@ -67,12 +67,12 @@ export interface collection {
  *             | LEVENS | TODO | TODO| TODO  |
  * ```
  * */
-export interface term {
+export interface Term {
   /**
    * must be one of [ 'phr', 'tok' ], corresponding to `PHRASE` and
    * `TOKENS` respectively.
    **/
-  type: string
+  type: Type
   /**
    * the search string
    * */
@@ -81,13 +81,27 @@ export interface term {
    * must be one of [ '+', '?', '-' ] corresponding to `ANDS`, `ORS`, and
    * `NOTS`, respectively.
    * */
-  op: string
+  op: Operator
+}
+
+export enum Type {
+  phrase = 'phrase',
+  token = 'token',
+}
+
+export enum Operator {
+  AND = '+',
+  '+' = AND,
+  OR = '?',
+  '?' = OR,
+  NOT = '-',
+  '-' = NOT,
 }
 
 /**
  * passed to AQL `FILTER`
  * */
-export interface filter {
+export interface Filter {
   /** the arango document field name to filter on */
   field: string
   /** the high-level operator to filter by */

src/parse.ts

@@ -1,31 +1,133 @@
-import { term } from './lib/structs'
+import { Term, Type, Operator } from './lib/structs'
 
-export function parseQuery(queryString: string): term[] {
+export function parseQuery(queryString: string): Term[] {
   const queryRgx: RegExp = /[+?-]?(["'(]).+?(\1|\))|[^"'()\s]+/g
 
   let matches = queryString.match(queryRgx)
   if (!matches) return []
 
   return matches.map((match) => {
     /* strip op */
-    let op = '?'
+    let op = Operator.OR
     if (/[+?-]/.test(match[0])) {
-      op = match[0]
+      op = Operator[match[0]]
       match = match.substring(1)
     }
 
     if (match[0] == '"' || match[0] == "'") {
       return {
-        type: 'phr',
+        type: Type.phrase,
         val: match,
         op,
       }
     } else {
       return {
-        type: 'tok',
+        type: Type.token,
         val: match,
         op,
       }
     }
   })
 }
+
+export function parseQueryEXP(queryString: string): Term[] {
+  return lex(queryString)
+}
+
+class Char {
+  char: string
+  constructor(ch: string) {
+    this.char = ch
+  }
+
+  isSpace() {
+    return /\s/.test(this.char)
+  }
+  isOperator() {
+    return /[+-?]/.test(this.char)
+  }
+  isQuote() {
+    return /"|'/.test(this.char)
+  }
+}
+
+function lex(queryString: string) {
+  const tokens = []
+  let curToken = ''
+  let curTokenType: Type = Type.token
+  let curOperator: Operator = Operator.OR
+  let isToken = false
+
+  for (let i = 0; i < queryString.length; i++) {
+    const ch = new Char(queryString[i])
+    if (ch.isSpace()) {
+      if (curToken.length) {
+        if (curTokenType === Type.token) {
+          isToken = true
+        } else {
+          curToken += ch.char
+        }
+      }
+    } else if (ch.isOperator()) {
+      if (curToken.length) {
+        throw new ParseError(
+          ch.char,
+          i,
+          `Logical operator must precede query term.`,
+        )
+      }
+      curOperator = Operator[ch.char]
+    } else if (ch.isQuote()) {
+      if (curToken.length && curTokenType === Type.phrase) {
+        isToken = true
+      } else {
+        curTokenType = Type.phrase
+      }
+    } else {
+      curToken += ch.char
+    }
+
+    if (isToken) {
+      resetCur()
+    }
+  }
+  if (curToken.length) {
+    resetCur()
+  }
+
+  function resetCur() {
+    tokens.push({
+      type: curTokenType,
+      val: curToken,
+      op: curOperator,
+    })
+    curToken = ''
+    curTokenType = Type.token
+    curOperator = Operator.OR
+    isToken = false
+  }
+
+  return tokens
+}
+
+export class ParseError extends Error {
+  char: string
+  pos: number
+  constructor(char: string, pos: number, message: string) {
+    super(message)
+    this.char = char
+    this.pos = pos
+  }
+
+  print() {
+    return `err:  “ ${this.char} ” in position ${this.pos} ${this.message}`
+  }
+  // U+201C “
+  // U+201D ”
+}
+
+try {
+  console.log(parseQueryEXP('"+hello    -there"    -apple'))
+} catch (e) {
+  console.error(e)
+}