edit: multikey search passing tests, limit fix

breaking api change: limit will no longer accept a `end` key, but rather
will work as Arango and god intended, with a `count` key. in effect
though the package claimed to be offering start and end, end was
actually just a misnamed variable, and was passed straight to
ArangoSearch's `COUNT` parameter. This means that the values passed
won't change, but the key name will have to in order to try to adhere to
Arango's specifications. Apologies to those for whom this breaking
change will come with only a patch version change

Author: hp4k1h5

README.md

@@ -151,12 +151,12 @@ const queryObject = {
   "query": "+'query string' -for +parseQuery ?to parse"
 }
 
-const limit = {start:1, end: 20}
+const limit = {start:0, count: 20}
 
 const aqlQuery = buildAQL(queryObject, limit)
 
 // ... const cursor = await db.query(aqlQuery)
-// ... const cursor = await db.query(buildAQL(queryObject, {start:21, end:40})
+// ... const cursor = await db.query(buildAQL(queryObject, {start:20, count:20})
 ```
 
 Generate documenation with `yarn doc && serve docs/` or see more examples in
@@ -210,18 +210,18 @@ the following shape:
 
 #### limit
 an object with the following keys:
-- `start` (integer), 1-based result pagination lower bound.
-- `end` (integer) 1-based result pagination upper bound
-i.e. to bring back up to the first 20 results
+- `start` (integer) 0-based result pagination lower bound.
+- `count` (integer) total number of results to return.
+i.e. to bring back up to the first 10 results
 ```json
-{start:1, end:20}
+{"start":0, "count":10}
 ```
 and the next page would be
 ```json
-{start:21, end:40}
+{"start":10, "count":10}
 ```
 
-#### `query` Example
+#### `query` example
 ```json
 {
   "view": "the_arango-search_view-name",
@@ -251,22 +251,10 @@ and the next page would be
 
 ___
 
-#### `limit` object 
-the second parameter passed to `buildAQL(query, limit)`
-
-optional, default `{start:1, end: 20}`, **start** (optional | default: 1): the
-1-based inclusive starting index of the result set to return.
 
 **end** (optional: default: 20): the 1-based inclusive ending index of the
 result set to result
 
-#### `limit` Example
-```json
-{
-  "start": 21,
-  "end": 40
-}
-```
 
 ___
 ### boolean search logic

src/index.ts

@@ -5,15 +5,22 @@ import { buildFilters } from './filter'
 export { buildFilters } from './filter'
 export { parseQuery } from './parse'
 
-/** @returns an AQL query object. See @param query for
- * details on required values. @param query.terms accepts
- * either a string to be parsed or an array of terms. @param limit is an object with keys `start` default 0, and `end` default 20.
- * */
+/** @returns an AQL query object. See @param query for details on required
+ * values. @param query.terms accepts either a string to be parsed or an array
+ * of terms.
+ *
+ * ! NOTE: v0.1.1 introduced a breaking change to adhere to the ArangoSearch
+ * spec. Please refer to
+ * <https://www.arangodb.com/docs/stable/aql/operations-limit.html> @param
+ * limit is an object with keys `start` @default 0, and `count` @default 20 */
 export function buildAQL(
   query: query,
-  limit: any = { start: 0, end: 20 },
+  limit: any = { start: 0, count: 20 },
 ): any {
   validateQuery(query)
+  /* unify query.key */
+  query.key = query.key ? query.key : ['text']
+  query.key = typeof query.key == 'string' ? [query.key] : query.key
 
   const SEARCH = buildSearch(query)
   const FILTER = query.filters && buildFilters(query.filters)

src/lib/structs.ts

@@ -16,10 +16,9 @@ export interface query {
    * */
   terms: term[] | string
   /**
-   * the name of the document key to search, currently must be the same across
-   * all documents. @default "text"
+   * the name(s) of the document key to search. @default "text"
    * */
-  key?: string
+  key?: string[] | string
   /**
    * a list of @filter interfaces. All filters are implicitly AND'ed together.
    * */

src/search.ts

@@ -7,6 +7,8 @@ export function buildSearch(query: query): any {
   query.terms =
     typeof query.terms == 'string' ? parseQuery(query.terms) : query.terms
 
+  query.key = typeof query.key == 'string' ? [query.key] : query.key
+
   /* build boolean pieces */
   let ANDS = buildOps(query.collections, query.terms, '+', query.key)
   let ORS = buildOps(query.collections, query.terms, '?', query.key)
@@ -41,7 +43,7 @@ function buildOps(
   collections: collection[],
   terms: term[],
   op: string,
-  key: string[] | string = 'text',
+  key: string[],
 ): any {
   const opWord: string = op == '+' ? ' AND ' : ' OR '
 
@@ -65,7 +67,7 @@ function buildOps(
 function buildPhrases(
   phrases: term[],
   collections: collection[],
-  key: string[] | string,
+  key: string[],
   opWord: string,
 ): any {
   if (!phrases.length) return undefined
@@ -79,18 +81,23 @@ function buildPhrases(
 function buildPhrase(
   phrase: term,
   collections: collection[],
-  key: string[] | string,
+  key: string[],
 ): any {
-  const phrases = collections.map((coll) => {
-    return aql`PHRASE(doc.${key}, ${phrase.val.slice(1, -1)}, ${coll.analyzer})`
-  })
+  const phrases = []
+  key.forEach((k: string) =>
+    collections.forEach((coll) =>
+      phrases.push(
+        aql`PHRASE(doc.${k}, ${phrase.val.slice(1, -1)}, ${coll.analyzer})`,
+      ),
+    ),
+  )
   return aql`(${aql.join(phrases, ' OR ')})`
 }
 
 function buildTokens(
   tokens: term[],
   collections: collection[],
-  key: string[] | string,
+  key: string[],
 ): any {
   if (!tokens.length) return
 
@@ -110,12 +117,17 @@ function buildTokens(
     tokens: term[],
     op: string,
     analyzer: string,
-    key: string[] | string,
+    key: string[],
   ) => {
-    return aql`
+    return aql.join(
+      key.map(
+        (k) => aql`
       ANALYZER(
         TOKENS(${tokens}, ${analyzer})
-        ${aql.literal(op)} IN doc.${key}, ${analyzer})`
+        ${aql.literal(op)} IN doc.${k}, ${analyzer})`,
+      ),
+      ' OR ',
+    )
   }
 
   let remapped = []

tests/search.ts

@@ -8,25 +8,37 @@ describe('search.ts', () => {
 
   it(`should return SEARCH true 
       when terms: is an empty string or array`, () => {
-
     /* empty string */
-    let empty_string_query = { view: 'search_view', collections: [ { name: 'coll', analyzer: 'text_en' } ], terms: '' }
+    let empty_string_query = {
+      view: 'search_view',
+      collections: [{ name: 'coll', analyzer: 'text_en' }],
+      terms: '',
+    }
     const builtSearch = buildSearch(empty_string_query)
 
     expect(builtSearch).to.be.an('object')
     expect(Object.keys(builtSearch.bindVars)).to.have.length(2)
     expect(builtSearch.bindVars.value0).to.equal(true)
-    expect(builtSearch.bindVars.value1).to.deep.equal({ collections: [ 'coll' ] })
+    expect(builtSearch.bindVars.value1).to.deep.equal({ collections: ['coll'] })
 
     /* empty array */
-    let empty_array_query = { view: 'search_view', collections: [ { name: 'coll', analyzer: 'text_en' } ], terms: [] }
+    let empty_array_query = {
+      view: 'search_view',
+      collections: [{ name: 'coll', analyzer: 'text_en' }],
+      terms: [],
+    }
     const builtSearch_from_array = buildSearch(empty_array_query)
 
     expect(builtSearch_from_array.bindVars.value0).to.equal(true)
   })
 
   it(`should handle single phrase queries`, () => {
-    const query = { view: 'search_view', collections: [ { name: 'coll', analyzer: 'text_en' } ], terms: '"complex phrase"' }
+    const query = {
+      view: 'search_view',
+      collections: [{ name: 'coll', analyzer: 'text_en' }],
+      terms: '"complex phrase"',
+      key: ['text'],
+    }
     const builtSearch = buildSearch(query)
 
     expect(builtSearch.query).to.equal(`
@@ -41,7 +53,12 @@ describe('search.ts', () => {
 
   it(`should return an array of aql objects
      when a complex query is passed`, () => {
-    const query = { view: 'search_view', collections: [ { name: 'coll', analyzer: 'text_en' } ], terms: '-a +"query string" ?token' }
+    const query = {
+      view: 'search_view',
+      collections: [{ name: 'coll', analyzer: 'text_en' }],
+      terms: '-a +"query string" ?token',
+      key: ['text'],
+    }
     const builtSearch = buildSearch(query)
 
     expect(Object.keys(builtSearch.bindVars)).to.have.length(7)
@@ -50,7 +67,9 @@ describe('search.ts', () => {
     expect(builtSearch.bindVars.value2).to.deep.equal('text_en')
     expect(builtSearch.bindVars.value4).to.deep.equal(1)
     expect(builtSearch.bindVars.value5).to.deep.equal('a')
-    expect(builtSearch.bindVars.value6).to.deep.equal({ collections: [ query.collections[ 0 ].name ] })
+    expect(builtSearch.bindVars.value6).to.deep.equal({
+      collections: [query.collections[0].name],
+    })
     expect(builtSearch.query).to.equal(`
   SEARCH 
     (PHRASE(doc.@value0, @value1, @value2)) OR ((PHRASE(doc.@value0, @value1, @value2)) AND MIN_MATCH(
@@ -74,11 +93,14 @@ describe('search.ts', () => {
   it('should return an array of aql objects', () => {
     const query = {
       view: 'search_view',
-      collections: [ {
-        name: 'coll',
-        analyzer: 'text_en'
-      } ],
-      terms: '+mandatory -exclude ?"optional phrase"'
+      collections: [
+        {
+          name: 'coll',
+          analyzer: 'text_en',
+        },
+      ],
+      terms: '+mandatory -exclude ?"optional phrase"',
+      key: ['text'],
     }
     const builtSearch = buildSearch(query)
     expect(builtSearch.query).to.equal(`
@@ -108,11 +130,14 @@ describe('search.ts', () => {
   it('should handle exclude phrase', () => {
     const query = {
       view: 'search_view',
-      collections: [ {
-        name: 'coll',
-        analyzer: 'text_en'
-      } ],
-      terms: '-"exclude"'
+      collections: [
+        {
+          name: 'coll',
+          analyzer: 'text_en',
+        },
+      ],
+      terms: '-"exclude"',
+      key: ['text'],
     }
     const builtSearch = buildSearch(query)
     expect(builtSearch.query).to.equal(`
@@ -130,11 +155,14 @@ describe('search.ts', () => {
   it('should handle exclude token', () => {
     const query = {
       view: 'search_view',
-      collections: [ {
-        name: 'coll',
-        analyzer: 'text_en'
-      } ],
-      terms: '-exclude'
+      collections: [
+        {
+          name: 'coll',
+          analyzer: 'text_en',
+        },
+      ],
+      terms: '-exclude',
+      key: ['text'],
     }
     const builtSearch = buildSearch(query)
     expect(builtSearch.bindVars.value0).to.equal('exclude')