Drastically improved the quality of the MongoDB module facade

Author: ldaniels528

README.md

@@ -193,8 +193,8 @@ The following example demonstrates establishing a connection to MongoDB using Sc
   val url = "mongodb://localhost:27017/test"
 
   // Use connect method to connect to the Server
-  mongoClient.connect(url, (err: MongoError, db: MongoDatabase) => {
-    if (err.isDefined) {
+  mongoClient.connect(url, (err: js.Object, db: MongoDatabase) => {
+    if (isDefined(err) {
       console.log("Unable to connect to the mongoDB server. Error:", err)
     } else {
       //HURRAY!! We are connected. :)

angularjs/src/main/scala/com/github/ldaniels528/meansjs/angularjs/AngularJsHelper.scala

@@ -0,0 +1,50 @@
+package com.github.ldaniels528.meansjs.angularjs
+
+import scala.scalajs.js.JSON
+
+/**
+  * AngularJS Convenience Helper Functions
+  * @author [email protected]
+  */
+object AngularJsHelper {
+  private val HttpError = "Failed to process HTTP request:"
+
+  /**
+    * Exception Extensions
+    * @param cause the given [[Throwable exception]]
+    * @author [email protected]
+    */
+  implicit class ExceptionExtensions(val cause: Throwable) extends AnyVal {
+
+    @inline
+    def displayMessage = Option(cause.getMessage) match {
+      case Some(s) if s.startsWith(HttpError) => cleanUp(s.drop(HttpError.length))
+      case Some(s) => s
+      case None => "Cause unknown"
+    }
+
+    private def cleanUp(s: String) = s.replaceAllLiterally("\"", "").replaceAllLiterally("'", "")
+
+  }
+
+  /**
+    * Convenience methods for strings
+    * @param string the given host string
+    */
+  implicit class StringExtensions(val string: String) extends AnyVal {
+
+    @inline
+    def indexOfOpt(substring: String): Option[Int] = Option(string).map(_.indexOf(substring)) flatMap {
+      case -1 => None
+      case index => Some(index)
+    }
+
+    @inline def isValidEmail: Boolean = {
+      string.matches("^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$")
+    }
+
+    @inline def parseAs[T] = JSON.parse(string).asInstanceOf[T]
+
+  }
+
+}

build.sbt

@@ -4,7 +4,7 @@ import sbt.Keys._
 import sbt.Project.projectToRef
 import sbt._
 
-val apiVersion = "0.1.0"
+val apiVersion = "0.1.1"
 val paradisePluginVersion = "2.1.0"
 val _scalaVersion = "2.11.8"
 val scalaJsDomVersion = "0.9.0"

core/src/main/scala/com/github/ldaniels528/meansjs/util/PromiseHelper.scala

@@ -0,0 +1,41 @@
+package com.github.ldaniels528.meansjs.util
+
+import org.scalajs.dom._
+
+import scala.concurrent.{ExecutionContext, Future}
+import scala.util.{Failure, Success}
+
+/**
+  * Promise Helper
+  * @author [email protected]
+  */
+object PromiseHelper {
+
+  ////////////////////////////////////////////////////////////////////////
+  //    Monitoring Functions
+  ////////////////////////////////////////////////////////////////////////
+
+  def time[T](action: String, task: => Future[T], showHeader: Boolean = true)(implicit ec: ExecutionContext): Future[T] = {
+    if (showHeader) console.info(s"$action...")
+    val startTime = System.currentTimeMillis()
+    task onComplete {
+      case Success(_) =>
+        console.info(s"$action took ${System.currentTimeMillis() - startTime} msecs")
+      case Failure(e) =>
+        console.warn(s"$action failed after ${System.currentTimeMillis() - startTime} msecs")
+    }
+    task
+  }
+
+  /**
+    * Time Measurement Extensions
+    * @param task the given [[Future task]]
+    * @tparam T the return type of the task
+    */
+  implicit class TimeExtensions[T](val task: Future[T]) extends AnyVal {
+
+    def withTimer(action: String, showHeader: Boolean = false)(implicit ec: ExecutionContext) = time(action, task, showHeader)
+
+  }
+
+}

core/src/main/scala/com/github/ldaniels528/meansjs/util/ScalaJsHelper.scala

@@ -1,25 +1,32 @@
 package com.github.ldaniels528.meansjs.util
 
-import org.scalajs.dom.console
-
-import scala.concurrent.{ExecutionContext, Future, Promise}
+import scala.concurrent.{Future, Promise}
 import scala.language.implicitConversions
 import scala.scalajs.js
-import scala.scalajs.js.JSON
 import scala.scalajs.runtime.wrapJavaScriptException
-import scala.util.{Failure, Success, Try}
 
 /**
-  * Scala.js Convenience Helper Functions
+  * ScalaJS Convenience Helper Functions
   * @author [email protected]
   */
 object ScalaJsHelper {
-  private val HttpError = "Failed to process HTTP request:"
 
   ////////////////////////////////////////////////////////////////////////
   //    Convenience Functions
   ////////////////////////////////////////////////////////////////////////
 
+  /**
+    * Converts a JavaScript-style callback to a Scala-style future
+    * @param f the given callback function
+    * @return a Scala-style future
+    */
+  @inline
+  def callbackToFuture[A](f: js.Function => Unit): Future[A] = {
+    val promise = Promise[A]()
+    f((result: A) => promise.success(result))
+    promise.future
+  }
+
   /**
     * Converts a JavaScript-style callback to a Scala-style future
     * @param f the given callback function
@@ -44,90 +51,17 @@ object ScalaJsHelper {
     promise.future
   }
 
-  @inline
-  def emptyArray[T] = js.Array[T]()
-
-  @inline
-  def New[T <: js.Any] = new js.Object().asInstanceOf[T]
-
-  ////////////////////////////////////////////////////////////////////////
-  //    Error-Handling Functions
-  ////////////////////////////////////////////////////////////////////////
-
-  /**
-    * Exception Extensions
-    * @param cause the given [[Throwable exception]]
-    * @author [email protected]
-    */
-  implicit class ExceptionExtensions(val cause: Throwable) extends AnyVal {
-
-    @inline
-    def displayMessage = Option(cause.getMessage) match {
-      case Some(s) if s.startsWith(HttpError) => cleanUp(s.drop(HttpError.length))
-      case Some(s) => s
-      case None => "Cause unknown"
-    }
-
-    private def cleanUp(s: String) = s.replaceAllLiterally("\"", "").replaceAllLiterally("'", "")
-
-  }
-
-  ////////////////////////////////////////////////////////////////////////
-  //    Monitoring Functions
-  ////////////////////////////////////////////////////////////////////////
-
-  def time[T](action: String, task: => Future[T], showHeader: Boolean = true)(implicit ec: ExecutionContext): Future[T] = {
-    if (showHeader) console.info(s"$action...")
-    val startTime = System.currentTimeMillis()
-    task onComplete {
-      case Success(_) =>
-        console.info(s"$action took ${System.currentTimeMillis() - startTime} msecs")
-      case Failure(e) =>
-        console.warn(s"$action failed after ${System.currentTimeMillis() - startTime} msecs")
-    }
-    task
-  }
-
-  /**
-    * Time Measurement Extensions
-    * @param task the given [[Future task]]
-    * @tparam T the return type of the task
-    */
-  implicit class TimeExtensions[T](val task: Future[T]) extends AnyVal {
-
-    def withTimer(action: String, showHeader: Boolean = true)(implicit ec: ExecutionContext) = time(action, task, showHeader)
-
-  }
-
-  ////////////////////////////////////////////////////////////////////////
-  //    Validation Functions
-  ////////////////////////////////////////////////////////////////////////
-
   @inline
   def die[T](message: String): T = throw new IllegalStateException(message)
 
   @inline
-  def isDefined(obj: js.Any) = obj != null && !js.isUndefined(obj)
-
-  @inline
-  def isDefined(fx: js.Function) = fx != null && !js.isUndefined(fx)
-
-  @inline
-  def isFalse(obj: js.Dynamic) = !isTrue(obj)
-
-  @inline
-  def isTrue(obj: js.Dynamic) = isDefined(obj) && obj.as[Boolean]
-
-  @inline
-  def required(name: String, value: String) = if (value == null || value.trim.isEmpty) die(s"Required property '$name' is missing")
+  def emptyArray[T] = js.Array[T]()
 
   @inline
-  def required(name: String, value: js.Any) = if (!isDefined(value)) die(s"Required property '$name' is missing")
+  def isDefined(obj: js.Any) = obj != null && !js.isUndefined(obj)
 
   @inline
-  def required[T](name: String, value: js.Array[T], allowEmpty: Boolean = false) = {
-    if (value == null || (allowEmpty && value.isEmpty)) die(s"Required property '$name' is missing")
-  }
+  def New[T <: js.Any] = new js.Object().asInstanceOf[T]
 
   ////////////////////////////////////////////////////////////////////////
   //    Implicit Definitions and Classes
@@ -144,31 +78,10 @@ object ScalaJsHelper {
       js.Dynamic.newInstance(obj.asInstanceOf[js.Dynamic])(args: _*).asInstanceOf[T]
     }
 
-    @inline
-    def ===[T](value: T): Boolean = {
-      if (value == null) !isDefined(obj)
-      else {
-        Try(obj.asInstanceOf[T]) match {
-          case Success(converted) => converted == value
-          case Failure(e) =>
-            console.log(s"JsDynamicExtensionsA: value '$value': ${e.getMessage}")
-            false
-        }
-      }
-    }
-
-    @inline def as[T] = if (isDefined(obj)) obj.asInstanceOf[T] else null.asInstanceOf[T]
-
     @inline def asOpt[T] = obj.asInstanceOf[js.UndefOr[T]].toOption
 
-    @inline def asArray[T] = obj.asInstanceOf[js.Array[T]]
-
     @inline def dynamic = obj.asInstanceOf[js.Dynamic]
 
-    @inline def isTrue = isDefined(obj) && Try(obj.asInstanceOf[Boolean]).toOption.contains(true)
-
-    @inline def toUndefOr[T]: js.UndefOr[T] = obj.asInstanceOf[js.UndefOr[T]]
-
   }
 
   /**
@@ -197,26 +110,6 @@ object ScalaJsHelper {
     }
   }
 
-  /**
-    * Value to js.Dynamic Extensions
-    * @param value the given [[String value]]
-    */
-  implicit class JsDynamicExtensions(val value: String) extends AnyVal {
-
-    @inline
-    def ===(obj: js.Dynamic): Boolean = {
-      if (!isDefined(obj)) value == null
-      else {
-        Try(obj.asInstanceOf[String]) match {
-          case Success(converted) => converted == value
-          case Failure(e) =>
-            console.log(s"JsDynamicExtensionsB: value '$value': ${e.getMessage}")
-            false
-        }
-      }
-    }
-  }
-
   /**
     * Option Extensions
     * @param valueA the given [[Option option]]
@@ -233,24 +126,6 @@ object ScalaJsHelper {
 
   }
 
-  /**
-    * Convenience methods for strings
-    * @param string the given host string
-    */
-  implicit class StringExtensions(val string: String) extends AnyVal {
-
-    @inline
-    def indexOfOpt(substring: String): Option[Int] = Option(string).map(_.indexOf(substring)) flatMap {
-      case -1 => None
-      case index => Some(index)
-    }
-
-    @inline def isValidEmail: Boolean = string.matches("^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$")
-
-    @inline def parseAs[T] = JSON.parse(string).asInstanceOf[T]
-
-  }
-
   /**
     * UndefOr Extensions
     * @param valueA the given [[js.UndefOr undefined or otherwise value]]

examples/package.json

@@ -9,9 +9,10 @@
     "express": "4.13.4",
     "express-ws": "^2.0.0-beta",
     "fs": "0.0.2",
+    "gridfs-stream": "^1.1.1",
     "html": "0.0.10",
     "kafka-node": "^0.3.2",
-    "mongoose": "4.4.11",
+    "mongodb": "^2.1.18",
     "node-zookeeper-client": "^0.2.2",
     "readline": "^1.3.0"
   }

examples/src/main/javascript/nodejs/mongo/GridFSBucketExample.js

@@ -0,0 +1,29 @@
+/**
+ * GridFS Bucket Example
+ * @author [email protected]
+ */
+(function() {
+
+    var assert = require('assert');
+    var fs = require('fs');
+    var mongodb = require('mongodb');
+
+    var uri = 'mongodb://localhost:27017/test';
+
+    mongodb.MongoClient.connect(uri, function(error, db) {
+        assert.ifError(error);
+
+        var bucket = new mongodb.GridFSBucket(db);
+
+        fs.createReadStream('/tmp/kickin_combo_2.jpg').
+        pipe(bucket.openUploadStream('meistersinger.mp3')).
+        on('error', function(error) {
+            assert.ifError(error);
+        }).
+        on('finish', function() {
+            console.log('done!');
+            process.exit(0);
+        });
+    });
+
+})();