Update readme and remove dependencies

Author: Thomas Hansen

README.md

@@ -1,123 +1,109 @@
 # Mongo-Postgres Query Converter
 [MongoDB query documents](https://docs.mongodb.org/manual/tutorial/query-documents/) are quite powerful.
-This brings part of that usefulsness to PostgreSQL by letting you query in a similar way.
-This tool converts a Mongo query to a PostgreSQL "where" clause for data stored in a jsonb field.
-It also has additional converters for Mongo projections which are like "select" clauses and for update queries.
-
-The goal of this is to eventually provide an adapter which lets Postgres serve as a drop in replacement for Mongo, but that is not there yet.
-Currently the project has many of the underlying conversions that will be required to do this.
-For that project, see [pgmongo](https://github.com/thomas4019/pgmongo).
-
-### Select Query Example 1
-```javascript
-{ 'address.city': 'provo',
-  name: 'Thomas',
-  age: { '$gte': '30' } }
-```
-becomes the following Postgres query
-```sql
-(data->'address'->>'city'='provo') and (data->>'name'='Thomas') and (data->>'age'>='30')
-```
+This brings that usefulness to PostgreSQL by letting you query in a similar way.
+This tool converts a Mongo query to a PostgreSQL `where` clause for data stored in a jsonb field.
+It also has additional converters for Mongo projections which are like `select` clauses and for `update` queries.
 
-### Select Query Example 2
-```javascript
-{
-     $or: [ { qty: { $gt: 100 } }, { price: { $lt: 9.95 } } ]
-}
-```
-becomes the following Postgres query
-```sql
-((data->'qty'>'100'::jsonb) OR (data->'price'<'9.95'::jsonb))
-```
+This tool is used by [pgmongo](https://github.com/thomas4019/pgmongo) which intends to provide a drop-in replacement for MongoDB.
 
-## Getting Started
+## Installation
 
-```bash
+```sh
 npm install mongo-query-to-postgres-jsonb
 ```
 
-```javascript
-var mongoToPostgres = require('mongo-query-to-postgres-jsonb')
+## Simple Usage
+
+```js
+var mToPsql = require('mongo-query-to-postgres-jsonb')
 var query = { field: 'value' }
-var sqlQuery = mongoToPostgres('data', query)
-console.log(sqlQuery)
+var sqlQuery = mToPsql('data', query)
 ```
 
-The first parameter, "data", is the name of your jsonb column in your postgres table.
-The second parameter is the Mongo style query.
-There is an optional third parameter explained in the next section.
+## API
 
-### Projection Example
-
-```javascript
-mongoToPostgres.convertSelect('data', { field: 1 })
-```
-becomes the following Postgres query
-```sql
-jsonb_build_object('field', data->'field', '_id', data->'_id')'
+```js
+var mToPsql = require('mongo-query-to-postgres-jsonb')
 ```
 
-### Update Example
+### mToPsql(sqlField, mongoQuery, [arrayFields])
 
+#### sqlField
 
-```javascript
-mongoToPostgres.convertUpdate('data', {
-  $set: { active: true },
-  $inc: { purchases: 2 }
-})
-```
-becomes the following Postgres query
-```sql
-jsonb_set(jsonb_set(data,'{active}','true'::jsonb),'{purchases}',to_jsonb(Cast(data->>'purchases' as numeric)+2))
-```
+This is the name of your jsonb column in your postgres table which holds all the data.
 
-### Sort Example
+#### mongoQuery
 
-```javascript
-mongoToPostgres.convertSort('data', {
-  age: -1,
-  'first.name': 1
-})
-```
-becomes the following Postgres query
-```sql
-data->'age' DESC, data->'first'->'name' ASC
-```
+An object containing MongoDB [query operators](https://docs.mongodb.com/manual/reference/operator/query/).
+
+#### arrayFields
+
+This tool doesn't know which fields are arrays so you can optionally specify a list of dotted paths which should be treated as an array.
+
+### mToPsql.convertSelect(sqlField, projectionQuery)
+
+#### projectionQuery
+
+Object specifying which a subset of documents to return. Note: advanced [projection fields](https://docs.mongodb.com/manual/reference/operator/projection/) are not yet supported. 
+
+### mToPsql.convertUpdate(sqlField, updateQuery, [upsert])
+
+#### updateQuery
+
+Object containing [MongoDB operations](https://docs.mongodb.com/manual/reference/operator/update/) to apply to the documents. 
+
+#### upsert
+
+Indicate that the query is being used for upserting. This will create a safer query that works if the original document doesn't already exist.
+
+### mToPsql.convertSort(sqlField, sortQuery, [forceNumericSort])
+
+#### sortQuery
+
+Object containing [desired ordering](https://docs.mongodb.com/manual/reference/method/cursor.sort/#sort-asc-desc)
+
+#### forceNumericSort
+
+Cast strings to number when sorting. 
+
+## Examples
+
+| Languages  | MongoDB                       |  Postgres                                                                       |
+|------------|-------------------------------|---------------------------------------------------------------------------------|
+| Where      | { 'address.city': 'provo' }   |  (data->'address'->>'city' = 'provo')                                           |
+| Where      | { $or: [ { qty: { $gt: 100 } }, { price: { $lt: 9.95 } } ] } |  ((data->'qty'>'100'::jsonb) OR (data->'price'<'9.95'::jsonb))   |
+| Projection | { field: 1 }                  |  jsonb_build_object('field', data->'field', '_id', data->'_id')'                |
+| Update     | { $set: { active: true } }    |  jsonb_set(data,'{active}','true'::jsonb)                                       |
+| Update     | { $inc: { purchases: 2 } }    |  jsonb_set(data,'{purchases}',to_jsonb(Cast(data->>'purchases' as numeric)+2))  |
+| Sort       | { age: -1,   'first.name': 1} |  data->'age' DESC, data->'first'->'name' ASC                                    |
 
-## Select: Match a Field Without Specifying Array Index
+## Advanced Select: Match a Field Without Specifying Array Index
 
 * [Mongo Docs](https://docs.mongodb.org/manual/tutorial/query-documents/#match-a-field-without-specifying-array-index)
 
-You can have a document with an array of objects that you want to match when any one of the elements in the array matches.
-This is implemented in SQL using a subquery so it may not be the most efficient.
+With MongoDB, you can search a document with a subarray of objects that you want to match when any one of the elements in the array matches.
+This tools implements it in SQL using a subquery so it is not be the most efficient.
 
 Example document.
-```javascript
+```js
 {
   "courses": [{
-    "distance": "5K"
-  }, {
-    "distance": "10K"
-  }]
-}
+      "distance": "5K"
+    }, {
+      "distance": "10K"
+    }]
+]
 ```
-Unlike Mongo, this tool doesn't know which fields are arrays and requires you to supply a list optionally as a third parameter.
-Example query to match when there is a course with a distance of "5K".
-```javascript
+Example query to match:
+```js
 mongoToPostgres('data', { 'courses.distance': '5K' }, ['courses'])
 ```
     
 ## Supported Features
 * $eq, $gt, $gte, $lt, $lte, $ne
-* $or, $not, $nin
-* [$in](https://docs.mongodb.org/manual/reference/operator/query/in/#use-the-in-operator-to-match-values-in-an-array), $nin
+* $or, $not, [$in](https://docs.mongodb.org/manual/reference/operator/query/in/#use-the-in-operator-to-match-values-in-an-array), $nin
 * $elemMatch
-* [$regex](https://docs.mongodb.com/manual/reference/operator/query/regex/)
-* [$type](https://docs.mongodb.org/manual/reference/operator/query/type/#op._S_type)
-* [$size](https://docs.mongodb.org/manual/reference/operator/query/size/#op._S_size)
-* [$exists](https://docs.mongodb.org/manual/reference/operator/query/exists/#op._S_exists)
-* [$mod](https://docs.mongodb.com/manual/reference/operator/query/mod/)
-* [$all](https://docs.mongodb.com/manual/reference/operator/query/all/)
+* [$regex](https://docs.mongodb.com/manual/reference/operator/query/regex/), [$type](https://docs.mongodb.org/manual/reference/operator/query/type/#op._S_type), [$size](https://docs.mongodb.org/manual/reference/operator/query/size/#op._S_size), [$exists](https://docs.mongodb.org/manual/reference/operator/query/exists/#op._S_exists), [$mod](https://docs.mongodb.com/manual/reference/operator/query/mod/), [$all](https://docs.mongodb.com/manual/reference/operator/query/all/)
 
 ## Todo
 * Filtering
@@ -136,4 +122,4 @@ mongoToPostgres('data', { 'courses.distance': '5K' }, ['courses'])
 * [PostgreSQL json documentation](http://www.postgresql.org/docs/9.4/static/datatype-json.html)
 * [MongoDB query documention](https://docs.mongodb.org/manual/tutorial/query-documents/)
 * [PostgreSQL Array Functions](https://www.postgresql.org/docs/9.3/static/functions-array.html)
-* [JSON array to PostgreSQL Array](https://dba.stackexchange.com/questions/54283/how-to-turn-json-array-into-postgres-array/54289#54289)
+* [JSON array to PostgreSQL Array](https://dba.stackexchange.com/questions/54283/how-to-turn-json-array-into-postgres-array/54289#54289)

index.js

@@ -1,5 +1,4 @@
 const util = require('./util.js')
-const _ = require('lodash')
 
 // These are the simple operators.
 // Note that "is distinct from" needs to be used to ensure nulls are returned as expected, see https://modern-sql.com/feature/is-distinct-from
@@ -135,7 +134,7 @@ function convertOp(path, op, value, parent, arrayPaths) {
       const type = util.getPostgresTypeName(value)
       return 'jsonb_typeof(' + text + ')=' + util.quote(type)
     case '$size':
-      if (typeof value !== 'number' || value < 0 || !_.isInteger(value)) {
+      if (typeof value !== 'number' || value < 0 || !Number.isInteger(value)) {
         throw new Error('$size only supports positive integer')
       }
       var text = util.pathToText(path, false)
@@ -212,4 +211,4 @@ module.exports.pathToText = util.pathToText
 module.exports.countUpdateSpecialKeys = util.countUpdateSpecialKeys
 module.exports.convertSelect = require('./select')
 module.exports.convertUpdate = require('./update')
-module.exports.convertSort = require('./sort')
+module.exports.convertSort = require('./sort')

package-lock.json

@@ -1,14 +1,12 @@
 {
   "name": "mongo-query-to-postgres-jsonb",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Converts MongoDB queries to postgresql queries for jsonb fields.",
   "main": "index.js",
   "directories": {
     "test": "test"
   },
-  "dependencies": {
-    "lodash": "^4.17.11"
-  },
+  "dependencies": {},
   "devDependencies": {
     "chai": "^4.2.0",
     "mocha": "^5.2.0"

package.json

@@ -151,6 +151,12 @@ describe('$size', function () {
   it('match array sizes', function() {
     assert.equal('jsonb_array_length(data->\'arr\')=3', convert('data', { arr: { $size: 3 } }))
   })
+  it('fail for strings', function() {
+    assert.throws(() => convert('data', { arr: { $size: 'abc' } }), '$size only supports positive integer')
+  })
+  it('fail for decimals', function() {
+    assert.throws(() => convert('data', { arr: { $size: 3.5 } }), '$size only supports positive integer')
+  })
 })
 
 describe('$type', function () {

test/filter.js

@@ -23,6 +23,9 @@ describe('update: ', function() {
     it('$set deep', function() {
       assert.equal(convertUpdate('data', { $set: { 'a.b': 2 } }), 'jsonb_set(jsonb_set(data,\'{a}\',COALESCE(data->\'a\', \'{}\'::jsonb)),\'{a,b}\',\'2\'::jsonb)')
     })
+    it('$set fails for _id', function() {
+      assert.throws(() => convertUpdate('data', { $set: { _id: 'b' } }), 'Mod on _id not allowed')
+    })
 
     it('$unset', function() {
       assert.equal(convertUpdate('data', { $unset: { field: 'value' } }), 'data #- \'{field}\'')

test/update.js

@@ -1,4 +1,3 @@
-const _ = require('lodash')
 const util = require('./util.js')
 const convertWhere = require('./index.js')
 
@@ -7,7 +6,7 @@ function convertOp(input, op, data, fieldName, upsert) {
   const value = data[pathText]
   delete data[pathText]
   if (Object.keys(data).length > 0) {
-    input = convertOp(input, op, data, fieldName, upsert)
+    input = convertOp(input, op, Object.assign({}, data), fieldName, upsert)
   }
   const path = pathText.split('.')
   const pgPath = util.toPostgresPath(path)
@@ -26,7 +25,7 @@ function convertOp(input, op, data, fieldName, upsert) {
           }
         }
       }
-      if (_.last(path) === '_id' && !upsert) {
+      if (path[path.length - 1] === '_id' && !upsert) {
         throw new Error('Mod on _id not allowed')
       }
       return 'jsonb_set(' + input + ',' + pgPath + ',' + util.quote2(value) + ')'
@@ -78,13 +77,13 @@ var convert = function (fieldName, update, upsert) {
   let keys = Object.keys(update)
   // $set needs to happen first
   if (keys.includes('$set')) {
-    keys = ['$set'].concat(_.pull(keys, '$set'))
+    keys = ['$set'].concat(keys.filter((v) => v !== '$set'))
   }
   keys.forEach(function(key) {
     if (!util.updateSpecialKeys.includes(key)) {
       throw new Error('The <update> document must contain only update operator expressions.')
     }
-    output = convertOp(output, key, _.cloneDeep(update[key]), fieldName, upsert)
+    output = convertOp(output, key, Object.assign({}, update[key]), fieldName, upsert)
   })
   return output
 }