.eslintrc

@@ -1,6 +1,23 @@
 {
+  "parserOptions": {
+    "ecmaVersion": 2019
+  },
   "env": {
-    "mocha": true
+    "mocha": true,
+    "node": true,
+    "es6": true
+  },
+  "globals": {
+    "expect": true,
+    "sinon": true
+  },
+  "rules": {
+    "camelcase": 1,
+    "new-cap": 0,
+    "no-use-before-define": 0
   },
-  "extends": "mongodb-js/node"
+  "extends": [
+    "mongodb-js/node",
+    "mongodb-js/browser"
+  ]
 }

.github/workflows/unit-tests.yml

@@ -0,0 +1,22 @@
+name: unit tests
+
+on: [push, pull_request]
+
+jobs:
+  unitTest:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm ci
+      - run: npm run check
+      - run: npm test
+      - run: npm run coverage

.gitignore

@@ -29,3 +29,8 @@ node_modules
 # Release artifacts
 .lone/
 dist/
+
+# Test output
+.nyc_output
+# Mac OS files on folder create/delete
+.DS_Store 

.npmignore

@@ -12,3 +12,5 @@ test/
 *.log
 coverage/
 .eslintrc
+.nyc_output
+**/*.DS_Store

README.md

@@ -17,7 +17,7 @@ the collection in JSON format to stdout.
 
 ```
 mongodb-schema mongodb://localhost:27017 mongodb.fanclub
-```            
+```
 
 Additional arguments change the number of samples (`--sample`), print additional statistics about the
 schema analysis (`--stats`), switch to a different output format (`--format`), or let you suppress the
@@ -28,7 +28,7 @@ For more information, run
 
 ```
 mongodb-schema --help
-```    
+```
 
 ### API
 
@@ -55,19 +55,22 @@ below accordingly).
 3. Create a new file `parse-schema.js` and paste in the following code:
 
     ```javascript
-    var parseSchema = require('mongodb-schema');
-    var connect = require('mongodb');
+    const parseSchema = require('mongodb-schema');
+    const MongoClient = require('mongodb').MongoClient;
+    const dbName = 'test';
 
-    connect('mongodb://localhost:27017/test', function(err, db) {
+    MongoClient.connect(`mongodb://localhost:27017/${dbName}`, { useNewUrlParser: true }, function(err, client) {
       if (err) return console.error(err);
 
+      const db = client.db(dbName);
+
       // here we are passing in a cursor as the first argument. You can
       // also pass in a stream or an array of documents directly.
       parseSchema(db.collection('data').find(), function(err, schema) {
         if (err) return console.error(err);
 
         console.log(JSON.stringify(schema, null, 2));
-        db.close();
+        client.close();
       });
     });
     ```
@@ -195,7 +198,7 @@ function emailDetector(value, path) {
   return emailRegex.test(value);
 };
 
-parseSchema(db.collection('data').find(), {EmailAddress: emailDetector}, function(err, schema) {
+parseSchema(db.collection('data').find(), { semanticTypes: { EmailAddress: emailDetector } }, function(err, schema) {
   ...
 });
 ```

bin/mongodb-schema

@@ -141,7 +141,7 @@ var bar = new ProgressBar('analyzing [:bar] :percent :etas ', {
   clear: true
 });
 
-mongodb.connect(uri, function(err, conn) {
+mongodb.connect(uri, {useUnifiedTopology: true}, function(err, conn) {
   if (err) {
     console.error('Failed to connect to MongoDB: ', err);
     process.exit(1);

examples/parse-schema.js

@@ -1,19 +1,22 @@
 /* eslint no-console: 0 */
 
-var parseSchema = require('../');
-var connect = require('mongodb');
+const parseSchema = require('../');
+const MongoClient = require('mongodb').MongoClient;
+const dbName = 'mongodb';
 
-connect('mongodb://localhost:27017/mongodb', function(err, db) {
+MongoClient.connect(`mongodb://localhost:27017/${dbName}`, function(err, client) {
   if (err) {
     return console.error(err);
   }
 
+  const db = client.db(dbName);
+
   parseSchema(db.collection('fanclub').find().limit(100), function(err2, schema) {
     if (err2) {
       return console.error(err);
     }
 
     console.log(JSON.stringify(schema, null, 2));
-    db.close();
+    client.close();
   });
 });

lib/index.js

@@ -1,6 +1,5 @@
 var stream = require('./stream');
 var es = require('event-stream');
-var _ = require('lodash');
 
 // var debug = require('debug')('mongodb-schema:wrapper');
 
@@ -14,43 +13,55 @@ var _ = require('lodash');
  * @param {Boolean}  options.semanticTypes  enable semantic type detection (default: false)
  * @param {Boolean}  options.storeValues    enable storing of values (default: true)
  *
- * @param {Function} fn      Callback which will be passed `(err, schema)`
+ * @param {Function} callback      Callback which will be passed `(err, schema)`
+ * @return {Promise} You can await promise, or use callback if provided.
  */
-module.exports = function(docs, options, fn) {
-  // shift parameters if no options are specified
-  if (_.isUndefined(options) || _.isFunction(options) && _.isUndefined(fn)) {
-    fn = options;
-    options = {};
-  }
+module.exports = function(docs, options, callback) {
+  const promise = new Promise((resolve, reject) => {
+    // shift parameters if no options are specified
+    if (typeof options === 'undefined' || (typeof options === 'function' && typeof callback === 'undefined')) {
+      callback = options;
+      options = {};
+    }
+
+    var src;
+    // MongoDB Cursors
+    if (docs.stream && typeof docs.stream === 'function') {
+      src = docs.stream();
+      // Streams
+    } else if (docs.pipe && typeof docs.pipe === 'function') {
+      src = docs;
+      // Arrays
+    } else if (Array.isArray(docs)) {
+      src = es.readArray(docs);
+    } else {
+      reject(new Error(
+        'Unknown input type for `docs`. Must be an array, ' +
+          'stream or MongoDB Cursor.'
+      ));
+      return;
+    }
+
+    var result;
+
+    src
+      .pipe(stream(options))
+      .on('data', function(data) {
+        result = data;
+      })
+      .on('error', function(err) {
+        reject(err);
+      })
+      .on('end', function() {
+        resolve(result);
+      });
+  });
 
-  var src;
-  // MongoDB Cursors
-  if (docs.stream && typeof docs.stream === 'function') {
-    src = docs.stream();
-  // Streams
-  } else if (docs.pipe && typeof docs.pipe === 'function') {
-    src = docs;
-  // Arrays
-  } else if (_.isArray(docs)) {
-    src = es.readArray(docs);
-  } else {
-    fn(new Error('Unknown input type for `docs`. Must be an array, '
-      + 'stream or MongoDB Cursor.'));
-    return;
+  if (callback && typeof callback === 'function') {
+    promise.then(callback.bind(null, null), callback);
   }
 
-  var result;
-
-  src.pipe(stream(options))
-    .on('data', function(data) {
-      result = data;
-    })
-    .on('error', function(err) {
-      fn(err);
-    })
-    .on('end', function() {
-      fn(null, result);
-    });
+  return promise;
 };
 
 module.exports.stream = stream;

lib/semantic-types/index.js

@@ -1,4 +1,3 @@
 module.exports = {
-  'Email': require('./email'),
-  'GeoJSON': require('./geojson')
+  'Email': require('./email')
 };

lib/stats.js

@@ -1,4 +1,3 @@
-var _ = require('lodash');
 // var debug = require('debug')('mongodb-schema:stats');
 
 var widthRecursive = function(schema) {
@@ -8,17 +7,21 @@ var widthRecursive = function(schema) {
   }
   if (schema.fields !== undefined) {
     width += schema.fields.length;
-    width += _.sum(schema.fields.map(function(field) {
-      var doc = _.find(field.types, 'name', 'Document');
+
+    width += schema.fields.map(field => {
+      var doc = field.types.find(v => v.name === 'Document');
       return widthRecursive(doc);
-    }));
-    width += _.sum(schema.fields.map(function(field) {
-      var arr = _.find(field.types, 'name', 'Array');
+    }).reduce((p, c) => p + c || 0, 0);
+
+
+    width += schema.fields.map(field => {
+      var arr = field.types.find(v => v.name === 'Array');
       if (arr) {
-        var doc = _.find(arr.types, 'name', 'Document');
+        var doc = arr.types.find(v => v.name === 'Document');
         return widthRecursive(doc);
       }
-    }));
+    })
+      .reduce((p, c) => p + c || 0, 0);
   }
   return width;
 };
@@ -30,18 +33,19 @@ var depthRecursive = function(schema) {
   var maxChildDepth = 0;
   if (schema.fields !== undefined && schema.fields.length > 0) {
     maxChildDepth = 1 + Math.max(
-        _.max(schema.fields.map(function(field) {
-          var doc = _.find(field.types, 'name', 'Document');
+      Math.max(...schema.fields.map(field => {
+        var doc = field.types.find(v => v.name === 'Document');
+        return depthRecursive(doc);
+      })),
+      Math.max(...schema.fields.map(field => {
+        var arr = field.types.find(v => v.name === 'Array');
+        if (arr) {
+          var doc = arr.types.find(v => v.name === 'Document');
           return depthRecursive(doc);
-        })),
-        _.max(schema.fields.map(function(field) {
-          var arr = _.find(field.types, 'name', 'Array');
-          if (arr) {
-            var doc = _.find(arr.types, 'name', 'Document');
-            return depthRecursive(doc);
-          }
-          return 0;
-        })));
+        }
+        return 0;
+      }))
+    );
   }
   return maxChildDepth;
 };
@@ -55,21 +59,21 @@ var branchingFactors = function(schema) {
   if (schema.fields !== undefined && schema.fields.length > 0) {
     branchArray.push(schema.fields.length);
     res = schema.fields.map(function(field) {
-      var doc = _.find(field.types, 'name', 'Document');
+      var doc = field.types.find(v => v.name === 'Document');
       return branchingFactors(doc);
     });
-    branchArray.push.apply(branchArray, _.flatten(res, true));
+    branchArray.push(...res.flat(Infinity));
     res = schema.fields.map(function(field) {
-      var arr = _.find(field.types, 'name', 'Array');
+      var arr = field.types.find(v => v.name === 'Array');
       if (arr) {
-        var doc = _.find(arr.types, 'name', 'Document');
+        var doc = arr.types.find(v => v.name === 'Document');
         return branchingFactors(doc);
       }
       return [];
     });
-    branchArray.push.apply(branchArray, _.flatten(res, true));
+    branchArray.push(...res.flat(Infinity));
   }
-  return _.sortBy(branchArray).reverse();
+  return branchArray.sort().reverse();
 };
 
 module.exports = {