refactor(Connect, Discoverable, gulp): Initial es2015 refactor, babelify, add gulp

Author: jspizziri

.babelrc

@@ -0,0 +1 @@
+{ "presets": ["es2015"] }

.eslintrc

@@ -0,0 +1,38 @@
+{
+  "parser": "babel-eslint",
+  "env": {
+    "node": true,
+    "es6": true,
+    "browser": true,
+    "mocha": true
+  },
+  "rules": {
+    "eqeqeq": 2,
+    "no-caller": 2,
+    "no-else-return": 2,
+    "no-eq-null": 2,
+    "quotes": "single",
+    "no-new-func": 2,
+    "camelcase": [2, "always"],
+    "brace-style": [2, "stroustrup", { "allowSingleLine": true }],
+    "strict": [2, "global"],
+    "comma-spacing": [2, {"before": false, "after": true}],
+    "indent": [2, 4],
+    "key-spacing": [2, { "beforeColon": false, "afterColon": true, "align": "value" }],
+    "no-mixed-spaces-and-tabs": [2, "smart-tabs"],
+    "space-before-blocks": [2, "always"],
+    "space-before-function-paren": [2, "always"],
+    "space-in-brackets": [2, "always", {
+      "singleValue": false,
+      "objectsInArrays": true,
+      "arraysInArrays": true,
+      "arraysInObjects": true,
+      "objectsInObjects": true,
+      "propertyName": false
+    }],
+    "space-in-parens": [2, "never"],
+    "space-infix-ops": 2,
+    "space-return-throw-case": 2,
+    "dot-notation": 0
+  }
+}

dist/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var gulp = require('gulp');
+var clean = require('gulp-clean');
+var babel = require('gulp-babel');
+var sourcemaps = require('gulp-sourcemaps');
+
+var entry = 'index.js';
+var src = [entry, 'lib/**/*.js'];
+var srcOption = {
+  base: './'
+};
+var dest = './dist';
+
+
+gulp.task('clean', function() {
+  return gulp.src(dest, {
+      read: false
+    })
+    .pipe(clean());
+});
+
+
+gulp.task('node', ['clean'], function() {
+  return gulp.src(src, srcOption)
+    .pipe(sourcemaps.init())
+    .pipe(babel())
+    .pipe(sourcemaps.write('.', {
+      includeContent: false,
+      sourceRoot: '..'
+    }))
+    .pipe(gulp.dest(dest));
+});
+
+gulp.task('default', ['node']);

dist/index.js.map

@@ -1 +1,5 @@
-module.exports = require('./lib/connect');
+// Import Connect
+import Connect from './lib/Connect';
+
+// Export Connect
+export default Connect;

dist/lib/Connect.js

@@ -0,0 +1,101 @@
+"use strict";
+
+import Promise from "bluebird";
+import path from "path";
+import Sequelize from "sequelize";
+import Discoverable  from "./Discoverable";
+
+// Setup Logger
+// logger.level  = "info";   // Default log level to debug
+
+let instance = null;
+
+class Connection {
+
+  constructor(database, username, password, options={}, discover=["/model"], matcher=null, logger=console) {
+
+    if(instance) return instance;
+
+    this.database = database;
+    this.username = username;
+    this.password = password;
+    this.options = options;
+    this.discover = discover; // Set the default discovery paths to ["/model"]
+    this.matcher = matcher; // Set the default matcher to null
+    this.logger = logger;
+
+    // Expose db
+    this.models = {};
+    this.Sequelize = Sequelize; // Expose Sequelize
+
+    this._connect()
+      .then((connection) => {
+        return instance = connection;
+      });
+  }
+
+  /**
+   * Connect to the db
+   * @return {Object} A database object containing sequelize and models
+   */
+  _connect(){
+
+    // return the instance, although this shouldn't be being called externally
+    if(instance) return instance;
+
+    this.logger.log("info", "Connecting to: " + this.database + " as: " + this.username);
+
+    // Instantiate a new sequelize instance
+    let sequelize = new db.Sequelize(this.database, this.username, this.password, this.options);
+    let models = {};
+
+
+    let dir = typeof this.discover === "string" ? [this.discover] : this.discover;
+    let discoverable = new Discoverable(dir, this.matcher, this.logger);
+
+    return discoverable.discover()
+      .each((path) => {
+        // Import each discovered path
+        let model  = sequelize["import"](path);
+
+        if(model) {
+          this.logger.log("debug", "Import for path succeeded: " + path);
+          models[model.name] = model;
+        } else {
+          this.logger.log("debug", "Import for path failed: " + path);
+        }
+
+      })
+      .then((path) => {
+        // Execute the associate methods for each Model
+        this.logger.log("info","Import completed");
+
+        return Promise.each(Object.keys(models), (modelName) => {
+
+          if ("associate" in models[modelName]) {
+            this.logger.log("debug", "Associating Model: "+ modelName);
+            models[modelName].associate(models);
+          } else {
+            this.logger.log("debug", "Nothing to associate for Model: "+ modelName);
+          }
+        });
+
+      })
+      .then(() => {
+        // Syncronize the DB
+        this.logger.log("info", "Finished connecting to: " + database + " as: " + username);
+        return sequelize.sync();
+
+      })
+      .then(() => {
+        this.logger.log("info", "Finished synchronizing " + database);
+        // Expose objects
+        this.sequelize = sequelize;
+        this.models    = models;
+
+        return this;
+      });
+  }
+}
+
+export default Connection;

dist/lib/Connect.js.map

@@ -0,0 +1,78 @@
+import Promise from "bluebird";
+import _ from "lodash";
+import f from "fs";
+
+let fs = Promise.promisifyAll(f);
+
+class Discoverable {
+
+  constructor(paths, matcher, logger=console){
+    this.paths = paths;
+    this.matcher = matcher;
+    this.logger = logger;
+  }
+
+  /**
+   * Discover the specified path for files
+   * matching the given convention
+   *
+   * @return {Array} The array of matching files for the discoverable directories
+   */
+  discover() {
+
+    let discovered = [];
+
+    return Promise.each(this.paths, function(location){
+
+      // Recurse through the api directory and collect the models
+      return this._dive(location)
+        .then((results) => {
+          this.logger.log("debug", "Flattening results");
+          return _.flatten(results, true);
+        })
+        .filter((value) => {
+          return value !== false
+        })
+        .then((results) => {
+          this.logger.log("debug", "Assigning filtered results to discover: " + results);
+          return discovered = results;
+        });
+
+    }).then(() => {
+      return discovered;
+    });
+  }
+
+  /**
+   * [dive description]
+   * @param  {String} dir The directory to recurse through
+   * @return {Array}     An array of matching files at the given location
+   */
+  _dive(dir) {
+
+    // Read the directory
+    return fs.readdirAsync(dir).map((file) => {
+      let path = dir + "/" + file;  // Full path of that file
+      let stat = fs.statSync(path); // Get the file's stats
+
+      // If the file is a directory
+      if (stat && stat.isDirectory()) {
+        return this._dive(path); // Dive into the directory
+      } else {
+        // Allow user to define a custom matcher function
+        if(typeof this.matcher === 'function' && this.matcher(file) === true) {
+          this.logger.log("debug", "Discovered path: " + path);
+          return path;
+        } else if((file.indexOf(".") !== 0) && (file.indexOf(".model.js") > 0)) {
+          this.logger.log("debug", "Discovered path: " + path);
+          return path;
+        }
+
+        return false;
+      }
+    });
+
+  };
+}
+
+export default Discoverable;

dist/lib/Discoverable.js

@@ -1,11 +1,11 @@
 {
   "name": "sequelize-connect",
-  "version": "1.3.0",
+  "version": "2.0.0-alpha.1",
   "author": "Jacob Spizziri <jacob.spizziri@gmail.com> (https://github.com/jspizziri)",
   "license": "BSD-2-Clause",
   "description": "A simple connection wrapper for the sequelize ORM, making it easier to configure and build models & connections.",
   "homepage": "https://github.com/jspizziri/sequelize-singleton",
-  "main": "index.js",
+  "main": "dist/index.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/jspizziri/sequelize-connect.git"
@@ -24,15 +24,23 @@
   ],
   "dependencies": {
     "bluebird": "^2.10.2",
-    "commitizen": "^2.7.6",
-    "lodash": "^3.10.1",
-    "winston": "^1.1.1"
+    "lodash": "^3.10.1"
   },
   "peerDependencies": {
     "sequelize": ">=2.0"
   },
   "devDependencies": {
-    "cz-conventional-changelog": "^1.1.5"
+    "babel-core": "^6.9.0",
+    "babel-eslint": "^6.0.4",
+    "babel-preset-es2015": "^6.9.0",
+    "babelify": "^7.3.0",
+    "commitizen": "^2.7.6",
+    "cz-conventional-changelog": "^1.1.5",
+    "eslint": "^2.10.2",
+    "gulp": "^3.9.1",
+    "gulp-babel": "^6.1.2",
+    "gulp-clean": "^0.3.2",
+    "gulp-sourcemaps": "^1.6.0"
   },
   "config": {
     "commitizen": {