edit: parseQueryEXP passes almost same tests as parseQuery

there should be no breaking changes

Author: hp4k1h5

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hp4k1h5/aqlquerybuilder.js",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "license": "MIT",
   "main": "built/index.js",
   "types": "built/index.d.ts",

src/filter.ts

@@ -1,11 +1,11 @@
 import { aql } from 'arangojs'
-import { filter } from './lib/structs'
+import { Filter } from './lib/structs'
 
-export function buildFilters(filters: filter[]) {
+export function buildFilters(filters: Filter[]) {
   if (!filters.length) return
 
   let _filters = filters.map(
-    (f: filter) => aql`doc.${f.field} ${aql.literal(f.op)} ${f.val}`,
+    (f: Filter) => aql`doc.${f.field} ${aql.literal(f.op)} ${f.val}`,
   )
 
   return aql`FILTER ${aql.join(_filters, ' && ')}`

src/lib/structs.ts

@@ -85,8 +85,8 @@ export interface Term {
 }
 
 export enum Type {
-  phrase = 'phrase',
-  token = 'token',
+  phrase = 'phr',
+  token = 'tok',
 }
 
 export enum Operator {
@@ -109,3 +109,20 @@ export interface Filter {
   /** the query string to filter with */
   val: string | number | Date
 }
+
+export 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)
+  }
+}

src/parse.ts

@@ -1,4 +1,4 @@
-import { Term, Type, Operator } from './lib/structs'
+import { Term, Type, Operator, Char } from './lib/structs'
 
 export function parseQuery(queryString: string): Term[] {
   const queryRgx: RegExp = /[+?-]?(["'(]).+?(\1|\))|[^"'()\s]+/g
@@ -34,25 +34,8 @@ 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 = []
+  const lexes = []
   let curToken = ''
   let curTokenType: Type = Type.token
   let curOperator: Operator = Operator.OR
@@ -96,7 +79,7 @@ function lex(queryString: string) {
   }
 
   function resetCur() {
-    tokens.push({
+    lexes.push({
       type: curTokenType,
       val: curToken,
       op: curOperator,
@@ -107,7 +90,7 @@ function lex(queryString: string) {
     isToken = false
   }
 
-  return tokens
+  return lexes
 }
 
 export class ParseError extends Error {
@@ -125,9 +108,3 @@ export class ParseError extends Error {
   // U+201C “
   // U+201D ”
 }
-
-try {
-  console.log(parseQueryEXP('"+hello    -there"    -apple'))
-} catch (e) {
-  console.error(e)
-}

src/search.ts

@@ -1,5 +1,5 @@
 import { aql } from 'arangojs'
-import { query, collection, term } from './lib/structs'
+import { query, collection, Term, Type } from './lib/structs'
 import { parseQuery } from './parse'
 
 export function buildSearch(query: query): any {
@@ -36,14 +36,14 @@ export function buildSearch(query: query): any {
       OPTIONS { collections: ${cols} }
       SORT TFIDF(doc) DESC`
 }
-function buildOps(collections: collection[], terms: term[], op: string): any {
+function buildOps(collections: collection[], terms: Term[], op: string): any {
   const opWord: string = op == '+' ? ' AND ' : ' OR '
 
-  let queryTerms: any = terms.filter((t: term) => t.op == op)
+  let queryTerms: any = terms.filter((t: Term) => t.op == op)
   if (!queryTerms.length) return
 
   /* phrases */
-  let phrases = queryTerms.filter((qT: term) => qT.type == 'phr')
+  let phrases = queryTerms.filter((qT: Term) => qT.type == Type.phrase)
   phrases = buildPhrases(phrases, collections, opWord)
 
   /* tokens */
@@ -57,7 +57,7 @@ function buildOps(collections: collection[], terms: term[], op: string): any {
 }
 
 function buildPhrases(
-  phrases: term[],
+  phrases: Term[],
   collections: collection[],
   opWord: string,
 ): any {
@@ -69,7 +69,7 @@ function buildPhrases(
   )
 }
 
-function buildPhrase(phrase: term, collections: collection[]): any {
+function buildPhrase(phrase: Term, collections: collection[]): any {
   const phrases = []
   collections.forEach((coll) =>
     coll.keys.forEach((k: string) =>
@@ -81,7 +81,7 @@ function buildPhrase(phrase: term, collections: collection[]): any {
   return aql`(${aql.join(phrases, ' OR ')})`
 }
 
-function buildTokens(tokens: term[], collections: collection[]): any {
+function buildTokens(tokens: Term[], collections: collection[]): any {
   if (!tokens.length) return
 
   const opWordMap = {
@@ -97,7 +97,7 @@ function buildTokens(tokens: term[], collections: collection[]): any {
   }, {})
 
   const makeTokenAnalyzers = (
-    tokens: term[],
+    tokens: Term[],
     op: string,
     analyzer: string,
     keys: string[],

tests/bool.ts

@@ -211,8 +211,7 @@ describe('boolean search logic', () => {
       expect(result[0].title).to.equal('doc B')
     })
 
-    it(`should bring back only results matching AND'ed values
-       when +'ed TOKEN's are passed`, async () => {
+    it(`should bring back only results matching AND'ed values when +'ed TOKEN's are passed`, async () => {
       const info = await view.get()
       expect(info.name).to.be.a('string')
       let query = {

tests/parse.ts

@@ -15,14 +15,14 @@ describe('parse.ts', () => {
      when a string is passed with no op hints`, () => {
     const parsedQuery = parseQuery('terms "a and b" c')
     expect(parsedQuery).to.be.an('array').that.has.lengthOf(3)
-    expect(parsedQuery[ 0 ]).to.deep.equal({
-      op: "?",
-      type: "tok",
-      val: "terms",
+    expect(parsedQuery[0]).to.deep.equal({
+      op: '?',
+      type: 'tok',
+      val: 'terms',
     })
-    expect(parsedQuery[ 1 ]).to.deep.equal({
-      op: "?",
-      type: "phr",
+    expect(parsedQuery[1]).to.deep.equal({
+      op: '?',
+      type: 'phr',
       val: '"a and b"',
     })
   })
@@ -33,25 +33,25 @@ describe('parse.ts', () => {
 
     expect(parsedQuery).to.be.an('array').that.has.lengthOf(4)
 
-    expect(parsedQuery[ 0 ]).to.deep.equal({
+    expect(parsedQuery[0]).to.deep.equal({
       op: '?',
       type: 'tok',
       val: 'terms',
     })
 
-    expect(parsedQuery[ 1 ]).to.deep.equal({
+    expect(parsedQuery[1]).to.deep.equal({
       op: '+',
       type: 'phr',
       val: '"must have"',
     })
 
-    expect(parsedQuery[ 2 ]).to.deep.equal({
+    expect(parsedQuery[2]).to.deep.equal({
       op: '-',
       type: 'tok',
       val: 'cannot',
     })
 
-    expect(parsedQuery[ 3 ]).to.deep.equal({
+    expect(parsedQuery[3]).to.deep.equal({
       op: '-',
       type: 'phr',
       val: '"have this"',

tests/parseEXP.ts

@@ -0,0 +1,60 @@
+import { expect } from 'chai'
+import { parseQueryEXP } from '../src/parse'
+
+describe('parse.ts', () => {
+  it('should export a function parseQueryEXP', () => {
+    expect(parseQueryEXP).to.be.a('function')
+  })
+
+  it(`should return an an empty array 
+     when an empty string is passed`, () => {
+    expect(parseQueryEXP('')).to.be.an('array')
+  })
+
+  it(`should return an array of parsed optional term objects 
+     when a string is passed with no op hints`, () => {
+    const parsedQuery = parseQueryEXP('terms "a and b" c')
+    expect(parsedQuery).to.be.an('array').that.has.lengthOf(3)
+    expect(parsedQuery[0]).to.deep.equal({
+      op: '?',
+      type: 'tok',
+      val: 'terms',
+    })
+    expect(parsedQuery[1]).to.deep.equal({
+      op: '?',
+      type: 'phr',
+      val: 'a and b',
+    })
+  })
+
+  it(`should return an array of parsed term objects 
+     when a complex string is passed`, () => {
+    const parsedQuery = parseQueryEXP('terms +"must have" -cannot -"have this"')
+
+    expect(parsedQuery).to.be.an('array').that.has.lengthOf(4)
+
+    expect(parsedQuery[0]).to.deep.equal({
+      op: '?',
+      type: 'tok',
+      val: 'terms',
+    })
+
+    expect(parsedQuery[1]).to.deep.equal({
+      op: '+',
+      type: 'phr',
+      val: 'must have',
+    })
+
+    expect(parsedQuery[2]).to.deep.equal({
+      op: '-',
+      type: 'tok',
+      val: 'cannot',
+    })
+
+    expect(parsedQuery[3]).to.deep.equal({
+      op: '-',
+      type: 'phr',
+      val: 'have this',
+    })
+  })
+})