edit: optionalized query.key to accept string array

Author: hp4k1h5

README.md

@@ -88,7 +88,8 @@ also accommodate multiple key searches.
 ___
 ## setup
 
-1) running generated AQL queries will require a running arangodb instance.
+1) running generated AQL queries will require a running ArangoDB v3.6+
+instance. This package is tested against v3.6.5 🥑
 
 ## installation
 currently there is only support for server-side use.
@@ -97,7 +98,8 @@ currently there is only support for server-side use.
     or `npm install --save @hp4k1h5/AQLqueryBuilder.js`  
     in a directory containing a `package.json` file.  
    __or__  
-  clone this repository in your node compatible project.
+  clone this repository in your node compatible project. And run `yarn` from
+  inside the directory.
 
 2) import/require the exported functions
 ```js

src/lib/structs.ts

@@ -1,91 +1,91 @@
 /**
-* passed to buildAQL, i.e. `let generatedAQL = buildAQL(query)`. Properties
-* mimic or match those familiar to AQL.
-* */
+ * passed to buildAQL, i.e. `let generatedAQL = buildAQL(query)`. Properties
+ * mimic or match those familiar to AQL.
+ * */
 export interface query {
   /**
-  * the name of the ArangoSearch View the query will be run against
-  * */
-  view: string,
+   * the name of the ArangoSearch View the query will be run against
+   * */
+  view: string
   /**
-  * the names of the collections indexed by @param view to query
-  * */
-  collections: collection[],
+   * the names of the collections indexed by @param view to query
+   * */
+  collections: collection[]
   /**
-  * either an array of @param term interfaces or a string to be parsed by `parseQuery()`
-  * */
-  terms: term[] | string,
+   * either an array of @param term interfaces or a string to be parsed by `parseQuery()`
+   * */
+  terms: term[] | string
   /**
-  * the name of the document key to search, currently must be the same across
-  * all documents. @default "text"
-  * */
-  key?: string,
+   * the name of the document key to search, currently must be the same across
+   * all documents. @default "text"
+   * */
+  key?: string
   /**
-  * a list of @filter interfaces. All filters are implicitly AND'ed together.
-  * */
-  filters?: filter[],
+   * a list of @filter interfaces. All filters are implicitly AND'ed together.
+   * */
+  filters?: filter[]
 }
 
 /**
-* Each collection referenced by the ArangoSearch that the user wishes to
-* include in the query must be listed as a collection of the following shape.
-*
-* A collection can be referenced by several analyzers and each must have its
-* own entry in `query.collections` in order to be included in the search.  
-* 
-* Alternatively, a document can be stored in several collections.
-*
-* In either case all desired collection/analyzer combinations must be
-* specified.
-* */
+ * Each collection referenced by the ArangoSearch that the user wishes to
+ * include in the query must be listed as a collection of the following shape.
+ *
+ * A collection can be referenced by several analyzers and each must have its
+ * own entry in `query.collections` in order to be included in the search.
+ *
+ * Alternatively, a document can be stored in several collections.
+ *
+ * In either case all desired collection/analyzer combinations must be
+ * specified.
+ * */
 export interface collection {
   /**
-  * the name of the collection
-  * */
-  name: string,
+   * the name of the collection
+   * */
+  name: string
   /**
-  * the name of the text analyzer
-  * */
-  analyzer: string,
+   * the name of the text analyzer
+   * */
+  analyzer: string
 }
 
 /**
-* A piece of search query text. Can be a phrase or an individual word, and will
-* belong to one cell or other of the following grid:
-* ```
-*                       **ops**
-*             |        | ANDS | ORS | NOTS  | 
-*             | -----  | ---- | --- | ----- | 
-*  **types**  | PHRASE |      |     |       | 
-*             | TOKENS |      |     |       | 
-*             | PROXIM | TODO | TODO| TODO  | 
-* ```
-* */
+ * A piece of search query text. Can be a phrase or an individual word, and will
+ * belong to one cell or other of the following grid:
+ * ```
+ *                       **ops**
+ *             |        | ANDS | ORS | NOTS  |
+ *             | -----  | ---- | --- | ----- |
+ *  **types**  | PHRASE |  ✅  | ✅  |  ✅   |
+ *             | TOKENS |  ✅  | ✅  |  ✅   |
+ *             | PROXIM | TODO | TODO| TODO  |
+ * ```
+ * */
 export interface term {
-  /**  
-  * must be one of [ 'phr', 'tok' ], corresponding to `PHRASE` and
-  * `TOKENS` respectively. 
-  **/
-  type: string,
   /**
-  * the search string
-  * */
-  val: string,
+   * must be one of [ 'phr', 'tok' ], corresponding to `PHRASE` and
+   * `TOKENS` respectively.
+   **/
+  type: string
   /**
-  * must be one of [ '+', '?', '-' ] corresponding to `ANDS`, `ORS`, and
-  * `NOTS`, respectively.
-  * */
-  op: string,
+   * the search string
+   * */
+  val: string
+  /**
+   * must be one of [ '+', '?', '-' ] corresponding to `ANDS`, `ORS`, and
+   * `NOTS`, respectively.
+   * */
+  op: string
 }
 
 /**
-* passed to AQL `FILTER`
-* */
+ * passed to AQL `FILTER`
+ * */
 export interface filter {
   /** the arango document field name to filter on */
-  field: string,
+  field: string
   /** the high-level operator to filter by */
-  op: string,
+  op: string
   /** the query string to filter with */
-  val: string | number | Date,
+  val: string | number | Date
 }

src/parse.ts

@@ -6,15 +6,15 @@ export function parseQuery(queryString: string): term[] {
   let matches = queryString.match(queryRgx)
   if (!matches) return []
 
-  return matches.map(match => {
+  return matches.map((match) => {
     /* strip op */
     let op = '?'
-    if (/[+?-]/.test(match[ 0 ])) {
-      op = match[ 0 ]
+    if (/[+?-]/.test(match[0])) {
+      op = match[0]
       match = match.substring(1)
     }
 
-    if (match[ 0 ] == '"' || match[ 0 ] == "'") {
+    if (match[0] == '"' || match[0] == "'") {
       return {
         type: 'phr',
         val: match,

src/search.ts

@@ -8,9 +8,9 @@ export function buildSearch(query: query): any {
     typeof query.terms == 'string' ? parseQuery(query.terms) : query.terms
 
   /* build boolean pieces */
-  let ANDS = buildOPS(query.collections, query.terms, '+', query.key)
-  let ORS = buildOPS(query.collections, query.terms, '?', query.key)
-  let NOTS = buildOPS(query.collections, query.terms, '-', query.key)
+  let ANDS = buildOps(query.collections, query.terms, '+', query.key)
+  let ORS = buildOps(query.collections, query.terms, '?', query.key)
+  let NOTS = buildOps(query.collections, query.terms, '-', query.key)
 
   /* handle combinations */
   if (ANDS && ORS) {
@@ -22,7 +22,7 @@ export function buildSearch(query: query): any {
     ${NOTS.phrases ? aql.literal(' NOT ') : undefined} ${NOTS.phrases}
     ${NOTS.phrases && NOTS.tokens ? aql.literal(' AND ') : undefined} ${
       NOTS.tokens
-      }`
+    }`
   }
 
   /* if an empty query.terms string or array is passed, SEARCH true, bringing
@@ -37,11 +37,11 @@ export function buildSearch(query: query): any {
       SORT TFIDF(doc) DESC`
 }
 
-function buildOPS(
+function buildOps(
   collections: collection[],
   terms: term[],
   op: string,
-  key: string = 'text',
+  key: string[] | string = 'text',
 ): any {
   const opWord: string = op == '+' ? ' AND ' : ' OR '
 
@@ -56,16 +56,16 @@ function buildOPS(
   let tokens = queryTerms.filter((qT: { type: string }) => qT.type === 'tok')
   tokens = tokens && buildTokens(tokens, collections, key)
 
-  if (!phrases && !tokens) return
+  /* if (!phrases && !tokens) return */
   if (op == '-') return { phrases, tokens }
-  if (phrases && tokens) return aql.join([ phrases, tokens ], opWord)
+  if (phrases && tokens) return aql.join([phrases, tokens], opWord)
   return tokens || phrases
 }
 
 function buildPhrases(
   phrases: term[],
   collections: collection[],
-  key: string,
+  key: string[] | string,
   opWord: string,
 ): any {
   if (!phrases.length) return undefined
@@ -79,7 +79,7 @@ function buildPhrases(
 function buildPhrase(
   phrase: term,
   collections: collection[],
-  key: string,
+  key: string[] | string,
 ): any {
   const phrases = collections.map((coll) => {
     return aql`PHRASE(doc.${key}, ${phrase.val.slice(1, -1)}, ${coll.analyzer})`
@@ -90,7 +90,7 @@ function buildPhrase(
 function buildTokens(
   tokens: term[],
   collections: collection[],
-  key: string,
+  key: string[] | string,
 ): any {
   if (!tokens.length) return
 
@@ -101,16 +101,16 @@ function buildTokens(
   }
 
   const mapped = tokens.reduce((a, v) => {
-    const op = a[ opWordMap[ v.op ] ]
-    a[ opWordMap[ v.op ] ] = op ? op + ' ' + v.val : v.val
+    const op = a[opWordMap[v.op]]
+    a[opWordMap[v.op]] = op ? op + ' ' + v.val : v.val
     return a
   }, {})
 
   const makeTokenAnalyzers = (
     tokens: term[],
     op: string,
     analyzer: string,
-    key: string,
+    key: string[] | string,
   ) => {
     return aql`
       ANALYZER(
@@ -122,11 +122,11 @@ function buildTokens(
   collections.forEach((coll) => {
     remapped.push(
       ...Object.keys(mapped).map((op) =>
-        makeTokenAnalyzers(mapped[ op ], op, coll.analyzer, key),
+        makeTokenAnalyzers(mapped[op], op, coll.analyzer, key),
       ),
     )
   })
 
   return aql`MIN_MATCH(${aql.join(remapped, ', ')}, 
-    ${tokens[ 0 ].op === '-' ? collections.length : 1})`
+    ${tokens[0].op === '-' ? collections.length : 1})`
 }