property 'index' of undefined

.github/workflows/nodejs.yml

@@ -0,0 +1,32 @@
+name: Node CI
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [8.x, 10.x, 12.x]
+
+    services:
+      redisgraph:
+        image: redislabs/redisearch:latest
+        ports:
+          - 6379:6379
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: npm install, build, and test
+      run: |
+        npm ci
+        npm run build --if-present
+        npm test
+      env:
+        CI: true

.gitignore

@@ -60,3 +60,6 @@ typings/
 .DS_Store
 *.sock
 testing.js
+
+# misc
+

History.md

@@ -1,74 +1,4 @@
-1.0.0 / 
+0.0.1 / July 2017
 ==================
+  * Forked from Reds
 
- * Updated tests and benchmarks to take a connection object from an command line argument
- * Updated creaky dependencies 
- * Added the ability to plug in new natural language processor and options
-
-0.2.4 / 2013-08-10 
-==================
-
- * add function to limit the number of results (pagination)
- * fix failure on strings that do not contain words 
-
-0.2.3 / 2013-02-22 
-==================
-
-  * fix redis call to allow for multiple keywords
-
-0.2.2 / 2012-10-08 
-==================
-
-  * update natural. Closes #16
-
-0.2.1 / 2012-09-05 
-==================
-
-  * handle punctuation better [kbsymanz]
-
-0.2.0 / 2012-08-21 
-==================
-
-  * add weighted search [kbsymanz]
-  * update redis dep
-  * update natural dep
-
-0.1.4 / 2012-06-28 
-==================
-
-  * grr engines
-
-0.1.2 / 2012-01-30 
-==================
-
-  * Upgrade natural dep. Closes #7
-
-0.1.1 / 2011-11-16 
-==================
-
-  * Added support for node v0.5.x and v0.6.x
-  * Added `Query`
-
-0.1.0 / 2011-07-28 
-==================
-
-  * Added `Search` to allow multiple searches namespaced within Redis
-  * Added _web-search_ example
-  * Added _web-index_ example
-
-0.0.3 / 2011-07-27 
-==================
-
-  * Added simple example
-  * Changed: default `reds.search()` to intersection
-
-0.0.2 / 2011-07-27 
-==================
-
-  * Added `make benchmark`
-  * Changed: generate only a single redis client
-
-0.0.1 / 2011-07-27 
-==================
-
-  * Initial release

Readme.md

@@ -1,22 +1,30 @@
-# reds
+[![Actions Status](https://github.com/stockholmux/redredisearch/workflows/Node%20CI/badge.svg)](https://github.com/stockholmux/redredisearch/actions)
+[![npm version](https://badge.fury.io/js/redredisearch.svg)](https://badge.fury.io/js/redredisearch)
 
-  reds is a light-weight Redis search for node.js. This module was originally developed to provide search capabilities for [Kue](http://automattic.github.io/kue/) a priority job queue, however it is very much a light general purpose search library that could be integrated into a blog, a documentation server, etc.
+# RedRediSearch
 
+  RedRediSearch is a Node.js wrapper library for the [RediSearch](http://redisearch.io/) Redis module. It is more-or-less syntactically compatible with [Reds](https://github.com/tj/reds), another Node.js search library. RedRediSearch and RediSearch can provide full-text searching that is much faster than the original Reds library (see Benchmarks).
+
+
 ## Upgrading
 
-Version 1.0.0 is syntactically compatible with previous versions of reds (0.2.5). However, [natural](https://github.com/NaturalNode/natural) has been updated. Documents indexed with older installs of reds (using natural v0.2.0) may need to be re-indexed to avoid some edge cases.
+If you are upgrading from Reds, you'll need to make your `createSearch` asynchronous and re-index your data. Otherwise, your app-level logic and code should be compatible.
 
 ## Installation
 
-      $ npm install reds
+      $ npm install redredisearch
 
 ## Example
 
-The first thing you'll want to do is create a `Search` instance, which allows you to pass a `key`, used for namespacing within Redis so that you may have several searches in the same db. You may specify your own [node_redis](https://github.com/NodeRedis/node_redis) instance with the `reds.setClient` function.
+The first thing you'll want to do is create a `Search` instance, which allows you to pass a `key`, used for namespacing within RediSearch so that you may have several searches in the same Redis database. You may specify your own [node_redis](https://github.com/NodeRedis/node_redis) instance with the `redredisearch.setClient` function.
 
-    var search = reds.createSearch('pets');
+```js
+redredisearch.createSearch('pets',{}, function(err, search) {
+  /* ... */
+});
+```
 
- reds acts against arbitrary numeric or string based ids, so you could utilize this library with essentially anything you wish, even combining data stores. The following example just uses an array for our "database", containing some strings, which we add to reds by calling `Search#index()` padding the body of text and an id of some kind, in this case the index.
+You can then add items to the index with the `Search#index` function.
 
 ```js
 var strs = [];
@@ -28,44 +36,44 @@ strs.push('Manny is a cat');
 strs.push('Luna is a cat');
 strs.push('Mustachio is a cat');
 
-strs.forEach(function(str, i){ search.index(str, i); });
+redredisearch.createSearch('pets',{}, function(err,search) {
+  strs.forEach(function(str, i){ search.index(str, i); });
+});
 ```
 
- To perform a query against reds simply invoke `Search#query()` with a string, and pass a callback, which receives an array of ids when present, or an empty array otherwise.
+ To perform a query against the index simply invoke `Search#query()` with a string, and pass a callback, which receives an array of ids when present, or an empty array otherwise.
 
 ```js
 search
-  .query(query = 'Tobi dollars')
+  .query('Tobi dollars')
   .end(function(err, ids){
     if (err) throw err;
     console.log('Search results for "%s":', query);
     ids.forEach(function(id){
       console.log('  - %s', strs[id]);
     });
-    process.exit();
   });
   ```
 
- By default reds performs an intersection of the search words. The previous example would yield the following output since only one string contains both "Tobi" _and_ "dollars":
+ By default, queries are an intersection of the search words. The previous example would yield the following output since only one string contains both "Tobi" _and_ "dollars":
 
 ```
 Search results for "Tobi dollars":
   - Tobi wants four dollars
 ```
 
- We can tweak reds to perform a union by passing either "union" or "or" to `Search#type()` in `reds.search()` between `Search#query()` and `Search#end()`, indicating that _any_ of the constants computed may be present for the id to match.
+ We can tweak the query to perform a union by passing either "union" or "or" to `Search#type()` in `redredisearch.search()` between `Search#query()` and `Search#end()`, indicating that _any_ of the constants computed may be present for the `id` to match.
 
 ```js
 search
-  .query(query = 'tobi dollars')
+  .query('tobi dollars')
   .type('or')
   .end(function(err, ids){
     if (err) throw err;
     console.log('Search results for "%s":', query);
     ids.forEach(function(id){
       console.log('  - %s', strs[id]);
     });
-    process.exit();
   });
 ```
 
@@ -78,86 +86,127 @@ Search results for "tobi dollars":
   - Loki, Jane, and Tobi are ferrets
 ```
 
+RediSearch has an advanced query syntax that can be used by using the 'direct' search type. See the [RediSearch documentation](http://redisearch.io/Query_Syntax/) for this syntax.
+
+```js
+search
+  .query('(hello|hella) (world|werld)')
+  .type('direct')
+  .end(function(err, ids){
+    /* ... */
+  });
+```
+
+Also included in the package is the RediSearch Suggestion API. This has no corollary in the Reds module. The Suggestion API is ideal for auto-complete type situations and is entirely separate from the Search API. 
+
+```js
+var suggestions = redredisearch.suggestion('my-suggestion-list');
+
+suggestions.add(
+  'redis',                                            // add 'redis'
+  2,                                                  // with a 'score' of 2, this affects the position in the results, higher = higher up in results
+  function(err,sizeOfSuggestionList) { /* ... */ }    // callback
+);
+suggestions.add(
+  'redisearch',                                       
+  5,
+  function(err,sizeOfSuggestionList) { /* ... */ } 
+);
+suggestions.add(
+  'reds',                                       
+  1,
+  function(err,sizeOfSuggestionList) { /* ... */ } 
+);
+
+/* ... */
+
+sugggestions.get(
+  're',                                               // prefix - will find anything starting with "re"
+  function(err, returnedSuggestions) {
+    /* returnedSuggestions is set to [ "redisearch", "redis", "reds" ] */
+  }
+);
+
+sugggestions.get(
+  'redis',                                            // prefix - will find anything starting with "redis", so not "reds"
+  function(err, returnedSuggestions) {
+    /* returnedSuggestions is set to [ "redisearch", "redis" ] */
+  }
+)
+```
+
+There is also a `fuzzy` opt and `maxResults` that can either be set by chaining or by passing an object in the second argument in the constructor.
+
+
 ## API
 
 ```js
-reds.createSearch(key)
+redredisearch.createSearch(key, options, fn) : Search
+redredisearch.setClient(inClient)
+redredisearch.createClient()
+redredisearch.confirmModule(cb)
+redredisearch.words(str) : Array
+redredisearch.suggestionList(key,opts) : Suggestion
 Search#index(text, id[, fn])
 Search#remove(id[, fn]);
-Search#query(text, fn[, type]);
+Search#query(text, fn[, type]) : Query
+Query#type(type)
+Query#between(str)
+Query#end(fn)
+Suggestion#fuzzy(isFuzzy)
+Suggestion#maxResults(maxResults)
+Suggestion#add(str,score,fn)
+Suggestion#get(prefix,fn)
+Suggestion#del(str,fn)
+
 ```
 
  Examples:
 
 ```js
-var search = reds.createSearch('misc');
+var search = redredisearch.createSearch('misc');
 search.index('Foo bar baz', 'abc');
 search.index('Foo bar', 'bcd');
 search.remove('bcd');
 search.query('foo bar').end(function(err, ids){});
 ```
 
-## Extending reds
-
-Starting in 1.0.0, you can easily extend and expand how reds functions. When creating a new search, supply an object as the second argument. There are currently three properties that can be configured:
-
-- `nlpProcess` the natural language processing function. You can alter how the words are processed (split, stemmed, and converted to metaphones) using this function.
-- `writeIndex` how the items are written to the index. 
-- `removeIndex` how the items are removed from the index.
-
-See the `lib/reds.js` file for the implementation of each. Please keep in mind that changing these functions may invalidate your previously stored index.
-
-```js
-reds.createSearch('pets', {
-  nlpProcess  : yourNlpProcessingFunction,
-  writeIndex  : yourWriteIndexFunction,
-  removeIndex : yourRemoveIndexFunction
-});
-```
 
-## About
-
-  Currently reds strips stop words and applies the metaphone and porter stemmer algorithms to the remaining words before mapping the constants in Redis sets. For example the following text:
-
-    Tobi is a ferret and he only wants four dollars
+## Benchmarks
 
-  Converts to the following constant map:
-
-```js
-{
-  Tobi: 'TB',
-  ferret: 'FRT',
-  wants: 'WNTS',
-  four: 'FR',
-  dollars: 'DLRS'
-}
-```
+When compared to Reds, RedRediSearch is much faster at indexing and somewhat faster at query:
 
- This also means that phonetically similar words will match, for example "stefen", "stephen", "steven" and "stefan" all resolve to the constant "STFN". Reds takes this further and applies the porter stemming algorithm to "stem" words, for example "counts", and "counting" become "count".
+_Indexing - documents / second_
 
- Consider we have the following bodies of text:
+| Module         | Tiny | Small | Medium | Large |
+|----------------|------|-------|--------|-------|
+| Reds           | 122  | 75    | 10     |  0    |
+| RediRediSearch | 1,256| 501   | 132    |  5    |
 
-    Tobi really wants four dollars
-    For some reason tobi is always wanting four dollars
+_Query - queries / second_
 
- The following search query will then match _both_ of these bodies, and "wanting", and "wants" both reduce to "want".
+| Module         | 1 term | 2 terms / AND | 2 terms / OR | 3 terms / AND | 3 terms / OR | Long* / AND | Long* / OR | 
+|----------------|--------|---------------|--------------|---------------|--------------|------------|----------|
+| Reds           | 8,754  | 8,765         | 8,389        | 7,622         | 7,193        | 1,649      | 1,647 |
+| RedRediSearch  | 10,955 | 12,945        | 10,054       | 12,769        | 8,389        | 6,456      | 12,311 |
 
-    tobi wants four dollars
+The "Long" query string is taken from the Canadian Charter of Rights and Freedoms: "Everyone has the following fundamental freedoms: (a) freedom of conscience and religion;  (b) freedom of thought, belief, opinion and expression, including freedom of the press and other media of communication; (c) freedom of peaceful assembly; and (d) freedom of association." (Used because I just had it open in another tab...)
 
-## Benchmarks
+## Next steps
 
- Nothing scientific but preliminary benchmarks show that a small 1.6kb body of text is currently indexed in ~__6ms__, or __163__ ops/s. Medium bodies such as 40kb operate around __6__ ops/s, or __166ms__.
+- More coverage of RediSearch features
+- Tests
+- Better examples
 
- Querying with a multi-word phrase, and an index containing ~3500 words operates around __5300__ ops/s. Not too bad.
-
- If working with massive documents, you may want to consider adding a "keywords" field, and simply indexing it's value instead of multi-megabyte documents.
 
 ## License 
 
 (The MIT License)
 
 Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
 
+Modified work Copyright (c) 2017 Kyle Davis
+
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 'Software'), to deal in the Software without restriction, including