edit: formatting with prettierrc

Author: hp4k1h5

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true,
+}

src/index.ts

@@ -4,9 +4,13 @@ import { buildSearch } from './search'
 import { buildFilters } from './filter'
 
 /** @returns an AQL query object. See @param query for details on required
- * values. @parm query .terms accepts either a string to be parsed or an array of @param term
+ * values. @parm query .terms accepts either a string to be parsed or an array
+ * of @param term
  * */
-export function buildAQL(query: query, limit: any = { start: 0, end: 20 }): any {
+export function buildAQL(
+  query: query,
+  limit: any = { start: 0, end: 20 },
+): any {
   validateQuery(query)
 
   const SEARCH = buildSearch(query)
@@ -22,6 +26,8 @@ export function buildAQL(query: query, limit: any = { start: 0, end: 20 }): any
 }
 
 function validateQuery(query: query) {
-  if (!query.view.length) throw Error('query.view must be a valid ArangoSearch View name')
-  if (!query.collections.length) throw new Error('query.collections must have at least one name')
+  if (!query.view.length)
+    throw new Error('query.view must be a valid ArangoSearch View name')
+  if (!query.collections.length)
+    throw new Error('query.collections must have at least one name')
 }

src/parse.ts

@@ -1,4 +1,4 @@
-import {term} from './lib/structs'
+import { term } from './lib/structs'
 
 export function parseQuery(queryString: string): term[] {
   const queryRgx: RegExp = /[+?-]?(["'(]).+?(\1|\))|[^"'()\s]+/g
@@ -9,12 +9,12 @@ export function parseQuery(queryString: string): term[] {
   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

@@ -2,12 +2,10 @@ import { aql } from 'arangojs'
 import { query, collection, term } from './lib/structs'
 import { parseQuery } from './parse'
 
-
 export function buildSearch(query: query): any {
   /* parse string query */
-  query.terms = typeof query.terms == 'string'
-    ? parseQuery(query.terms)
-    : query.terms
+  query.terms =
+    typeof query.terms == 'string' ? parseQuery(query.terms) : query.terms
 
   /* build boolean pieces */
   let ANDS = buildOPS(query.collections, query.terms, '+', query.key)
@@ -22,7 +20,9 @@ export function buildSearch(query: query): any {
   if (!!NOTS) {
     NOTS = aql`${ANDS || ORS ? aql.literal(' AND ') : undefined} 
     ${NOTS.phrases ? aql.literal(' NOT ') : undefined} ${NOTS.phrases}
-    ${NOTS.phrases && NOTS.tokens ? aql.literal(' AND ') : undefined} ${NOTS.tokens}`
+    ${NOTS.phrases && NOTS.tokens ? aql.literal(' AND ') : undefined} ${
+      NOTS.tokens
+      }`
   }
 
   /* if an empty query.terms string or array is passed, SEARCH true, bringing
@@ -33,19 +33,24 @@ export function buildSearch(query: query): any {
     ${ORS}
     ${NOTS}
     ${(!ANDS && !ORS && !NOTS) || undefined}
-    OPTIONS ${{ collections: query.collections.map(c => c.name) }}
+    OPTIONS ${{ collections: query.collections.map((c) => c.name) }}
       SORT TFIDF(doc) DESC`
 }
 
-function buildOPS(collections: collection[], terms: term[], op: string, key:
-  string = 'text'): any {
+function buildOPS(
+  collections: collection[],
+  terms: term[],
+  op: string,
+  key: string = 'text',
+): any {
   const opWord: string = op == '+' ? ' AND ' : ' OR '
 
   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 == 'phr')
     .map((phrase: any) => buildPhrase(phrase, collections, key))
   if (!phrases.length) {
     phrases = undefined
@@ -60,17 +65,25 @@ function buildOPS(collections: collection[], terms: term[], op: string, key:
   if (!phrases && !tokens) return
   if (op == '-') return { phrases, tokens }
   if (phrases && tokens) return aql.join([ phrases, tokens ], opWord)
-  return (tokens || phrases)
+  return tokens || phrases
 }
 
-function buildPhrase(phrase: term, collections: collection[], key: string): any {
-  const phrases = collections.map(coll => {
+function buildPhrase(
+  phrase: term,
+  collections: collection[],
+  key: string,
+): any {
+  const phrases = collections.map((coll) => {
     return aql`PHRASE(doc.${key}, ${phrase.val.slice(1, -1)}, ${coll.analyzer})`
   })
   return aql`(${aql.join(phrases, ' OR ')})`
 }
 
-function buildTokens(tokens: term[], collections: collection[], key: string): any {
+function buildTokens(
+  tokens: term[],
+  collections: collection[],
+  key: string,
+): any {
   if (!tokens.length) return
 
   const opWordMap = {
@@ -85,19 +98,24 @@ function buildTokens(tokens: term[], collections: collection[], key: string): an
     return a
   }, {})
 
-  const makeTokenAnalyzers = (tokens: term[], op: string, analyzer: string,
-    key: string) => {
+  const makeTokenAnalyzers = (
+    tokens: term[],
+    op: string,
+    analyzer: string,
+    key: string,
+  ) => {
     return aql`
       ANALYZER(
         TOKENS(${tokens}, ${analyzer})
         ${aql.literal(op)} IN doc.${key}, ${analyzer})`
   }
 
   let remapped = []
-  collections.forEach(coll => {
+  collections.forEach((coll) => {
     remapped.push(
-      ...Object.keys(mapped).map(op => makeTokenAnalyzers(mapped[ op ], op,
-        coll.analyzer, key))
+      ...Object.keys(mapped).map((op) =>
+        makeTokenAnalyzers(mapped[ op ], op, coll.analyzer, key),
+      ),
     )
   })