├── .gitignore
├── README.md
├── bin
    └── recli.js
├── index.js
├── lib
    └── misc.js
├── package.json
└── test.js


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | node_modules/*
3 | npm-debug.log


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## recli - RethinkDB CLI query tool and REPL
  2 | **recli** is a command-line query tool and REPL for RethinkDB, with lots of options to control its output. It supports regular JavaScript syntax and CoffeeScript syntax.
  3 | 
  4 | ### Installation
  5 | Install recli using npm:
  6 | ```
  7 | sudo npm install -g recli
  8 | ```
  9 | This will give you a global `recli` command. If you prefer or need to install it locally, just drop the "sudo" and "-g". In that case, you can invoke it like so:
 10 | ```
 11 | node ./node_modules/recli
 12 | ```
 13 | or
 14 | ```
 15 | ./node_modules/recli/bin/recli.js
 16 | ```
 17 | 
 18 | You can of course create an alias to be able to type "recli", as if you had recli installed globally, just put something like this in your ~/.bash_profile or equivalent:
 19 | ```
 20 | alias recli='YOURDIR/node_modules/recli/bin/recli.js'
 21 | ```
 22 | 
 23 | ### Usage
 24 | recli can either take a ReQL expression as an argument or be used as a REPL, which lets you type in ReQL expressions in a special shell and see the results immediately.
 25 | 
 26 | Here’s how you would use it from the command line:
 27 | ```
 28 | $ recli 'r.table("bikes")'
 29 | ... (JSON output) ...
 30 | 
 31 | $ recli 'r.table("bikes").get("123").update({foo: "bar"})'
 32 | ... (JSON output) ...
 33 | ```
 34 | 
 35 | If you don’t supply a ReQL expression on the command-line, recli will start a REPL for ReQL queries, like so:
 36 | ```
 37 | $ recli
 38 | recli> r.table("bikes")
 39 | ... (JSON output) ...
 40 | recli> r.table("bikes").get("123").update({foo: "bar"})
 41 | ... (JSON output) ...
 42 | ```
 43 | Note that results from queries that return a cursor are automatically converted to arrays and printed as JSON documents.
 44 | 
 45 | ### Output
 46 | The default output from recli is a color-coded and pretty-formatted RethinkDB query result. It uses node’s util.inspect method, which means that it is actually a string representation of a Javascript object and NOT (by default) strictly valid JSON:
 47 | ```js
 48 | $ recli 'r.table("heroes")'
 49 | [ { hero: 'Magneto',
 50 |     name: 'Max Eisenhardt',
 51 |     aka: ['Magnus', 'Erik Lehnsherr', 'Lehnsherr'],
 52 |     magazine_titles:
 53 |      [ 'Alpha Flight',
 54 |        'Avengers',
 55 |        'Avengers West Coast' ],
 56 |     appearances_count: 42 },
 57 |   { hero: 'Professor Xavier',
 58 |     name: 'Charles Francis Xavier',
 59 |     magazine_titles:
 60 |      [ 'Alpha Flight',
 61 |        'Avengers',
 62 |        'Bishop',
 63 |        'Defenders' ],
 64 |     appearances_count: 72 },
 65 |   { hero: 'Storm',
 66 |     name: 'Ororo Monroe',
 67 |     magazine_titles:
 68 |      [ 'Amazing Spider-Man vs. Wolverine',
 69 |        'Excalibur',
 70 |        'Fantastic Four',
 71 |        'Iron Fist' ],
 72 |     appearances_count: 72 } ]
 73 | ```
 74 | Note that colors can be disabled by using the `-n`/`--no-colors` option.
 75 | 
 76 | If you want valid JSON instead, but still nicely indented and readable, use the `-j`/`--json` option:
 77 | ```
 78 | $ recli -j 'r.table("heroes")'
 79 | [ 
 80 |   { 
 81 |     "hero": "Magneto",
 82 |     "name": "Max Eisenhardt",
 83 |     "aka": [
 84 |       "Magnus", 
 85 |       "Erik Lehnsherr", 
 86 |       "Lehnsherr"
 87 |     ],
 88 |     "magazine_titles": [ 
 89 |       "Alpha Flight",
 90 |       "Avengers",
 91 |       "Avengers West Coast"
 92 |     ],
 93 |     "appearances_count": 42
 94 |   },
 95 |   { 
 96 |     "hero": "Professor Xavier",
 97 |     "name": "Charles Francis Xavier",
 98 |     "magazine_titles": [
 99 |       "Alpha Flight",
100 |       "Avengers",
101 |       "Bishop",
102 |       "Defenders"
103 |     ],
104 |     "appearances_count": 72
105 |   },
106 |   { 
107 |     "hero": "Storm",
108 |     "name": "Ororo Monroe",
109 |     "magazine_titles": [
110 |       "Amazing Spider-Man vs. Wolverine",
111 |       "Excalibur",
112 |       "Fantastic Four",
113 |       "Iron Fist"
114 |     ],
115 |     "appearances_count": 72
116 |   }
117 | ]
118 | ```
119 | 
120 | If you want raw, unformatted and unindented JSON, use the `-r`/`--raw` option. This isn’t straight-from-the-wire raw, though, it is the JSON.stringify-ed version of the RethinkDB result data (as returned by the JavaScript driver).
121 | 
122 | ### CoffeeScript input
123 | If you prefer to use the CoffeeScript syntax, use the `-c`/`--coffee` option:
124 | ```
125 | $ recli -c 'r.table "bikes"'
126 | ... (JSON output) ...
127 | ```
128 | 
129 | ### Database and connection options
130 | You can specify the database, host and port to connect to with the `-d`/`--database`, `-h`/`--host` and `-p`/`--port` options. 
131 | 
132 | Use `--help` to get the full usage info:
133 | ```
134 | $ recli --help
135 | Usage: recli [options] [ReQL expression]
136 | 
137 | REPL mode:
138 |     If the ReQL expression is omitted, recli will enter REPL mode,
139 |     which is a CLI where you can evaluate ReQL expressions.
140 | 
141 | REQL EXPRESSION:
142 |     A ReQL expression is anything that works in RethinkDB's Data
143 |     Explorer, for example
144 | 
145 |           r.table('bikes').filter({brand: 'Scott'})
146 | 
147 |           r.table('bikes').get('123').update({foo: 'bar'})
148 | 
149 | OPTIONAL options:
150 |     -c, --coffee               Evaluate code as CoffeeScript.
151 | 
152 |     -d, --database DATABASE    Default database to perform queries against.
153 |                                Can be overridden in the ReQL expression.
154 |                                The default is 'test'.
155 | 
156 |     -f, --file FILE            Read options from the supplied YAML config
157 |                                file. The default is to look for a global 
158 |                                /etc/recli.yml and user overrides in ~/.recli.yml
159 | 
160 |     -h, --host HOST            Host to connect to. The default is 'localhost'.
161 | 
162 |     -j, --json                 Output valid indented JSON instead of pretty-
163 |                                printing the result.
164 | 
165 |     -n, --no-colors            Do not use colors when pretty-printing.
166 | 
167 |     -p, --port PORT            TCP port to connect to. The default is 28015.
168 | 
169 |     -r, --raw                  Print the raw JSON from RethinkDB, with no
170 |                                formatting applied.
171 | 
172 |     -s, --stream               Print a line break delimited JSON stream with one
173 |                                valid JSON object per line.
174 | 
175 |     -v, --version              Print the current version of recli.
176 | ```
177 | Any options specified on the command line take precedence over defaults and configuration file settings.
178 | 
179 | Note that the `--coffee`, `--file`, `--json` and `--raw` options also support the `--no-<option>` syntax, like `--no-json`. This lets you override all configuration file settings.
180 | 
181 | ### Configuration files
182 | recli will look for YAML configuration files in `/etc/recli.yml` and `~/.recli.yml` by default. The user config overrides the global config. You can specify another configuration file by using the `-f`/`--file` option, in which case none of the default files are loaded.
183 | 
184 | The keys and values in the configuration files must match the (long-form) options that can be used on the command line (use `true` and `false` for flags):
185 | ```yaml
186 | # set default connection options
187 | database: mydb
188 | host: server1
189 | 
190 | # output valid JSON by default
191 | json: true
192 | 
193 | # prefer to use CoffeeScript input
194 | coffee: true
195 | ```
196 | 
197 | ### REPL history
198 | recli remembers commands that you run in the REPL (between sessions), which gives you access to previously run commands by pressing arrow-up. The history is stored in ~/.recli_history. There is currently no way to disable the history feature.
199 | 
200 | ### Author
201 | Stian Grytøyr
202 | 
203 | ### Contributors
204 | * Luc Heinrich
205 | * Marshall Cottrell
206 | * StreetStrider
207 | * Howard Tyson
208 | 
209 | ### Licence
210 | [The MIT License](http://opensource.org/licenses/MIT)
211 | 


--------------------------------------------------------------------------------
/bin/recli.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | 
3 | require('..');
4 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | var home = process.env[(process.platform == 'win32') ? 'USERPROFILE' : 'HOME'];
  2 | var defaultConfigFile = home + '/.recli.yml';
  3 | var r      = require('rethinkdb'),
  4 |     rhist  = require('repl.history'),
  5 |     coffee = require('coffee-script'),
  6 |     repl   = require('repl'),
  7 |     util   = require('util'),
  8 |     os     = require('os'),
  9 |     fs     = require('fs'),
 10 |     yaml   = require('js-yaml'),
 11 |     misc   = require('./lib/misc'),
 12 |     pj     = require('./package.json');
 13 |     opts   = require('optimist')
 14 |                .boolean(['c', 'colors', 'j', 'n', 'r', 'v', 's'])
 15 |                .default('colors', true)
 16 |                .default('file', defaultConfigFile)
 17 |                .alias('coffee',   'c')
 18 |                .alias('database', 'd')
 19 |                .alias('file',     'f')
 20 |                .alias('host',     'h')
 21 |                .alias('user',     'u')
 22 |                .alias('json',     'j')
 23 |                .alias('port',     'p')
 24 |                .alias('raw',      'r')
 25 |                .alias('stream',   's')
 26 |                .alias('version',  'v')
 27 |                .argv;
 28 | 
 29 | var writer = function(rawResult) {
 30 |   var result;
 31 |   if (opts.stream) {
 32 |     var i = 0;
 33 |     result = '';
 34 |     for (i in rawResult) {
 35 |       result += JSON.stringify(rawResult[i]) + os.EOL;
 36 |     }
 37 |   } else if (opts.raw) {
 38 |     result = JSON.stringify(rawResult);
 39 |   } else if (opts.json) {
 40 |     result = JSON.stringify(rawResult, null, 2);
 41 |   } else {
 42 |     result = util.inspect(rawResult, {depth: null, colors: opts.colors});
 43 |   }
 44 |   return result;
 45 | }
 46 | 
 47 | exports.recli = function() {
 48 |   if (opts.help) {
 49 |     misc.usage();
 50 |   } else if (opts.version) {
 51 |     console.log(pj.version);
 52 |   } else {
 53 |     var globalSettings = {};
 54 |     var userSettings   = {};
 55 |     if (opts.file) {
 56 |       // Only load global config file if a file has not been specified
 57 |       if (opts.file === defaultConfigFile) {
 58 |         try {
 59 |           globalSettings = yaml.safeLoad(fs.readFileSync('/etc/recli.yml', 'utf8'));
 60 |         } catch (e) {}
 61 |       }
 62 |       try {
 63 |         userSettings = yaml.safeLoad(fs.readFileSync(opts.file, 'utf8'));
 64 |       } catch (e) {}
 65 |     }
 66 |     opts = misc.setupOptions(opts, globalSettings, userSettings);
 67 | 
 68 |     r.connect({
 69 |       host:     opts.host,
 70 |       port:     opts.port,
 71 |       db:       opts.database,
 72 |       user:     opts.user,
 73 |       password: opts.password,
 74 |       authKey:  opts.auth
 75 |     }, function(err, conn) {
 76 |       if (err) {
 77 |         throw err;
 78 |       } else {
 79 |         if (opts._.length) {
 80 |           var code = opts._.join(' ');
 81 |           if (opts.coffee) {
 82 |             code = coffee.compile(code, {bare: true});
 83 |           }
 84 | 
 85 |           var re = eval(code);
 86 |           misc.evalResult(conn, re, function(e, result) {
 87 |             if (e) {
 88 |               throw e;
 89 |             } else {
 90 |               // Don't use console.log here. console.log is asynchronous so
 91 |               // big results won't be fully written if we call process.exit
 92 |               // too early.
 93 |               process.stdout.write(writer(result), function() {
 94 |                 process.exit();
 95 |               });
 96 |             }
 97 |           });
 98 |         } else {
 99 |           var cli = repl.start({prompt:    "recli> ",
100 |                                 eval:      misc.replEval,
101 |                                 writer:    writer});
102 |           cli.context.r = r;
103 |           cli.context.conn = conn;
104 |           cli.context.coffee = opts.coffee;
105 | 
106 |           cli.on('exit', function () {
107 |             console.log('');
108 |             process.exit();
109 |           });
110 |           rhist(cli, home + '/.recli_history');
111 |         }
112 |       }
113 |     });
114 |   }
115 | };
116 | 
117 | exports.recli();
118 | 
119 | 


--------------------------------------------------------------------------------
/lib/misc.js:
--------------------------------------------------------------------------------
  1 | var vm     = require('vm'),
  2 |     coffee = require('coffee-script')
  3 | 
  4 | // Make the rethinkdb result suitable for output
  5 | exports.evalResult = function(conn, result, callback) {
  6 |   if (typeof result.run === 'function') {
  7 |     result.run(conn, function(err, resultOrCursor) {
  8 |       if (err) {
  9 |         callback(err);
 10 |       } else {
 11 |         if (resultOrCursor) {
 12 |           if (typeof resultOrCursor.toArray === 'function') {
 13 |             resultOrCursor.toArray(callback);
 14 |           } else {
 15 |             callback(err, resultOrCursor);
 16 |           }
 17 |         } else {
 18 |           callback(null, null);
 19 |         }
 20 |       }
 21 |     });
 22 |   } else {
 23 |     callback(null, result);
 24 |   }
 25 | };
 26 | 
 27 | // Custom eval function for the repl module
 28 | exports.replEval = function(code, context, file, cb) {
 29 |   if (code === '(\n)') {
 30 |     cb(null, null);
 31 |   } else {
 32 |     var err, result, re;
 33 | 
 34 |     // we do not need force expression, just because we carefully check syntax later
 35 |     code = code.replace(/^\(/, '').replace(/\)$/, '');
 36 | 
 37 |     // first, create the Script object to check the syntax
 38 |     try {
 39 |       if (context.coffee) {
 40 |         code = coffee.compile(code, { bare: true });
 41 |       }
 42 | 
 43 |       var script = vm.createScript(code, {
 44 |         filename: file,
 45 |         displayErrors: false
 46 |       });
 47 |     } catch (e) {
 48 |       console.log('Script compile error:', e);
 49 |       console.log(e.stack);
 50 |       return;
 51 |     }
 52 | 
 53 |     // then, run in context
 54 |     if (!err) {
 55 |       try {
 56 |         re = script.runInContext(context, {displayErrors: false});
 57 |       } catch (e) {
 58 |         console.log('Runtime error:', e);
 59 |         console.log(e.stack);
 60 |         return;
 61 |       }
 62 |       exports.evalResult(context.conn, re, cb);
 63 |     }
 64 |   }
 65 | 
 66 | };
 67 | 
 68 | exports.setupOptions = function(rawOpts, globalSettings, userSettings) {
 69 |   var defaults = { coffee:   false,
 70 |                    database: 'test',
 71 |                    host:     'localhost',
 72 |                    user:     'admin',
 73 |                    password: '',
 74 |                    port:     28015,
 75 |                    colors:   true,
 76 |                    json:     false,
 77 |                    raw:      false,
 78 |                    stream:   false,
 79 |                    version:  false };
 80 | 
 81 |   if (rawOpts.n) rawOpts.colors = false;
 82 | 
 83 |   // Speed isn't crucial, so let's just cheat
 84 |   var opts = JSON.parse(JSON.stringify(defaults));
 85 |   opts['_'] = rawOpts['_'];
 86 |   opts['$0'] = rawOpts['$0'];
 87 | 
 88 |   // Override defaults with global settings
 89 |   for (var setting in globalSettings) {
 90 |     opts[setting] = globalSettings[setting]; 
 91 |   }
 92 | 
 93 |   // Override merged result with user settings
 94 |   for (var setting in userSettings) {
 95 |     opts[setting] = userSettings[setting]; 
 96 |   }
 97 | 
 98 |   // Override merged result with command-line options
 99 |   for (var opt in opts) {
100 |     if (rawOpts.hasOwnProperty(opt) && rawOpts[opt] !== opts[opt]) {
101 |       opts[opt] = rawOpts[opt];
102 |     }
103 |   }
104 | 
105 |   return opts;
106 | };
107 | 
108 | exports.usage = function() {
109 |   var usage = '\
110 | Usage: recli [options] [ReQL expression]                                        \n\
111 |                                                                                 \n\
112 | REPL mode:                                                                      \n\
113 |     If the ReQL expression is omitted, recli will enter REPL mode,              \n\
114 |     which is a CLI where you can evaluate ReQL expressions.                     \n\
115 |                                                                                 \n\
116 | REQL EXPRESSION:                                                                \n\
117 |     A ReQL expression is anything that works in RethinkDB\'s Data               \n\
118 |     Explorer, for example                                                       \n\
119 |                                                                                 \n\
120 |           r.table(\'bikes\').filter({brand: \'Scott\'})                         \n\
121 |                                                                                 \n\
122 |           r.table(\'bikes\').get(\'123\').update({foo: \'bar\'})                \n\
123 |                                                                                 \n\
124 | OPTIONAL options:                                                               \n\
125 |     -c, --coffee              Evaluate code as CoffeeScript.                    \n\
126 |                                                                                 \n\
127 |     -u, --user USERNAME       Changes the user that connects to the database.   \n\
128 |                                                                                 \n\
129 |     --password PASSWORD       Changes the password that is used to connect.     \n\
130 |                                                                                 \n\
131 |     -f, --file FILE           Read options from (only) the supplied YAML config \n\
132 |                               file. The default is to look for a global         \n\
133 |                               /etc/recli.yml and user overrides in ~/.recli.yml \n\
134 |                                                                                 \n\
135 |     -h, --host HOST           Host to connect to. The default is \'localhost\'. \n\
136 |                                                                                 \n\
137 |     -j, --json                Output valid indented JSON instead of pretty-     \n\
138 |                               printing the result.                              \n\
139 |                                                                                 \n\
140 |     -n, --no-colors           Do not use colors when pretty-printing.           \n\
141 |                                                                                 \n\
142 |     -p, --port PORT           TCP port to connect to. The default is 28015.     \n\
143 |                                                                                 \n\
144 |     -s, --stream              Print a line break delimited JSON stream with one \n\
145 |                               valid JSON object per line.                       \n\
146 |                                                                                 \n\
147 |     -r, --raw                 Print the raw JSON from RethinkDB, with no        \n\
148 |                               formatting applied.                               \n\
149 |                                                                                 \n\
150 |     -v, --version             Print the current version of recli.               \n\
151 |                                                                                 \n\
152 | \n';
153 |   console.log(usage);
154 | 
155 | };
156 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "recli",
 3 |   "version": "0.2.4",
 4 |   "author": "Stian Grytøyr",
 5 |   "description": "RethinkDB CLI query tool and REPL",
 6 |   "main": "index.js",
 7 |   "preferGlobal": true,
 8 |   "dependencies": {
 9 |     "coffee-script": "1.7.x",
10 |     "js-yaml": "3.0.x",
11 |     "optimist": "0.6.x",
12 |     "repl.history": "0.1.x",
13 |     "rethinkdb": "^2.3.3"
14 |   },
15 |   "devDependencies": {
16 |     "mocha": "1.12.x"
17 |   },
18 |   "bin": {
19 |     "recli": "./bin/recli.js"
20 |   },
21 |   "repository": {
22 |     "type": "git",
23 |     "url": "https://github.com/stiang/recli.git"
24 |   },
25 |   "keywords": [
26 |     "rethinkdb",
27 |     "reql",
28 |     "database",
29 |     "cli"
30 |   ],
31 |   "license": "MIT",
32 |   "bugs": {
33 |     "url": "https://github.com/stiang/recli/issues"
34 |   },
35 |   "contributors": [
36 |     {
37 |       "name": "Stian Grytøyr",
38 |       "email": "stian@grytoyr.net"
39 |     },
40 |     {
41 |       "name": "Luc Heinrich",
42 |       "email": "luc@honk-honk.com"
43 |     },
44 |     {
45 |       "name": "Marshall Cottrell"
46 |     },
47 |     {
48 |       "name": "StreetStrider"
49 |     },
50 |     {
51 |       "name": "Howard Tyson"
52 |     }
53 |   ],
54 |   "scripts": {
55 |     "test": "mocha -R spec ./test.js"
56 |   }
57 | }
58 | 


--------------------------------------------------------------------------------
/test.js:
--------------------------------------------------------------------------------
 1 | // This package is getting quite useful, but needs some tests!
 2 | // Please contribute if you can.
 3 | 
 4 | var assert  = require('assert');
 5 | 
 6 | describe('package', function () {
 7 | 
 8 |   it('should have basic tests', function() {
 9 |     assert.ok(false);
10 |   });
11 | 
12 | });
13 | 


--------------------------------------------------------------------------------