mongodb 2.1.0-alpha → 2.1.2

package/lib/url_parser.js

@@ -1,6 +1,8 @@
 "use strict";
 
-var ReadPreference = require('./read_preference');
+var ReadPreference = require('./read_preference'),
+  parser = require('url'),
+  f = require('util').format;
 
 module.exports = function(url, options) {
   // Ensure we have a default options object if none set
@@ -11,9 +13,85 @@ module.exports = function(url, options) {
   var query_string_part = '';
   var dbName = 'admin';
 
-  // Must start with mongodb
-  if(url.indexOf("mongodb://") != 0)
-    throw Error("URL must be in the format mongodb://user:pass@host:port/dbname");
+  // Url parser result
+  var result = parser.parse(url, true);
+
+  if(result.protocol != 'mongodb:') {
+    throw new Error('invalid schema, expected mongodb');
+  }
+
+  if((result.hostname == null || result.hostname == '') && url.indexOf('.sock') == -1) {
+    throw new Error('no hostname or hostnames provided in connection string');
+  }
+
+  if(result.port == '0') {
+    throw new Error('invalid port (zero) with hostname');
+  }
+
+  if(!isNaN(parseInt(result.port, 10)) && parseInt(result.port, 10) > 65535) {
+    throw new Error('invalid port (larger than 65535) with hostname');
+  }
+
+  if(result.path
+    && result.path.length > 0
+    && result.path[0] != '/'
+    && url.indexOf('.sock') == -1) {
+    throw new Error('missing delimiting slash between hosts and options');
+  }
+
+  if(result.query) {
+    for(var name in result.query) {
+      if(name.indexOf(':') != -1) {
+        throw new Error('double colon in host identifier');
+      }
+
+      if(result.query[name] == '') {
+        throw new Error('query parameter ' + name + ' is an incomplete value pair');
+      }
+    }
+  }
+
+  if(result.auth) {
+    var parts = result.auth.split(':');
+    if(url.indexOf(result.auth) != -1 && parts.length > 2) {
+      throw new Error('Username with password containing an unescaped colon');
+    }
+
+    if(url.indexOf(result.auth) != -1 && result.auth.indexOf('@') != -1) {
+      throw new Error('Username containing an unescaped at-sign');
+    }
+  }
+
+  // Remove query
+  var clean = url.split('?').shift();
+
+  // Extract the list of hosts
+  var strings = clean.split(',');
+  var hosts = [];
+
+  for(var i = 0; i < strings.length; i++) {
+    var hostString = strings[i];
+
+    if(hostString.indexOf('mongodb') != -1) {
+      if(hostString.indexOf('@') != -1) {
+        hosts.push(hostString.split('@').pop())
+      } else {
+        hosts.push(hostString.substr('mongodb://'.length));
+      }
+    } else if(hostString.indexOf('/') != -1) {
+      hosts.push(hostString.split('/').shift());
+    } else if(hostString.indexOf('/') == -1) {
+      hosts.push(hostString.trim());
+    }
+  }
+
+  for(var i = 0; i < hosts.length; i++) {
+    var r = parser.parse(f('mongodb://%s', hosts[i].trim()));
+    if(r.path && r.path.indexOf(':') != -1) {
+      throw new Error('double colon in host identifier');
+    }
+  }
+
   // If we have a ? mark cut the query elements off
   if(url.indexOf("?") != -1) {
     query_string_part = url.substr(url.indexOf("?") + 1);
@@ -33,7 +111,7 @@ module.exports = function(url, options) {
     if(connection_part.indexOf(".sock/") != -1) {
       dbName = connection_part.split(".sock/")[1];
       connection_part = connection_part.split("/", connection_part.indexOf(".sock") + ".sock".length);
-    } 
+    }
   } else if(connection_part.indexOf("/") != -1) {
     dbName = connection_part.split("/")[1];
     connection_part = connection_part.split("/")[0];
@@ -80,6 +158,9 @@ module.exports = function(url, options) {
   } else {
     // Split up the db
     hostPart = connection_part;
+    // Deduplicate servers
+    var deduplicatedServers = {};
+
     // Parse all server results
     servers = hostPart.split(',').map(function(h) {
       var _host, _port, ipv6match;
@@ -95,15 +176,22 @@ module.exports = function(url, options) {
         // Check for localhost?safe=true style case
         if(_host.indexOf("?") != -1) _host = _host.split(/\?/)[0];
       }
+
+      // No entry returned for duplicate servr
+      if(deduplicatedServers[_host + "_" + _port]) return null;
+      deduplicatedServers[_host + "_" + _port] = 1;
+
       // Return the mapped object
       return {host: _host, port: _port};
+    }).filter(function(x) {
+      return x != null;
     });
   }
 
   // Get the db name
   object.dbName = dbName || 'admin';
   // Split up all the options
-  urlOptions = (query_string_part || '').split(/[&;]/);    
+  urlOptions = (query_string_part || '').split(/[&;]/);
   // Ugh, we have to figure out which options go to which constructor manually.
   urlOptions.forEach(function(opt) {
     if(!opt) return;
@@ -143,6 +231,10 @@ module.exports = function(url, options) {
         serverOptions.ssl = (value == 'true');
         replSetServersOptions.ssl = (value == 'true');
         break;
+      case 'sslValidate':
+        serverOptions.sslValidate = (value == 'true');
+        replSetServerOptions.sslValidate = (value == 'true');
+        break;
       case 'replicaSet':
       case 'rs_name':
         replSetServersOptions.rs_name = value;
@@ -170,6 +262,9 @@ module.exports = function(url, options) {
       case 'native_parser':
         dbOptions.native_parser = (value == 'true');
         break;
+      case 'readConcernLevel':
+        dbOptions.readConcern = {level: value};
+        break;
       case 'connectTimeoutMS':
         serverOptions.socketOptions.connectTimeoutMS = parseInt(value, 10);
         replSetServersOptions.socketOptions.connectTimeoutMS = parseInt(value, 10);
@@ -201,15 +296,16 @@ module.exports = function(url, options) {
         } else if(value == 'MONGODB-X509') {
           object.auth = {user: decodeURIComponent(authPart)};
         }
-        
+
         // Only support GSSAPI or MONGODB-CR for now
-        if(value != 'GSSAPI' 
+        if(value != 'GSSAPI'
           && value != 'MONGODB-X509'
           && value != 'MONGODB-CR'
+          && value != 'DEFAULT'
           && value != 'SCRAM-SHA-1'
-          && value != 'PLAIN') 
-            throw new Error("only GSSAPI, PLAIN, MONGODB-X509, SCRAM-SHA-1 or MONGODB-CR is supported by authMechanism");
-        
+          && value != 'PLAIN')
+            throw new Error("only DEFAULT, GSSAPI, PLAIN, MONGODB-X509, SCRAM-SHA-1 or MONGODB-CR is supported by authMechanism");
+
         // Authentication mechanism
         dbOptions.authMechanism = value;
         break;
@@ -233,7 +329,7 @@ module.exports = function(url, options) {
         break;
       case 'readPreference':
         if(!ReadPreference.isValid(value)) throw new Error("readPreference must be either primary/primaryPreferred/secondary/secondaryPreferred/nearest");
-        dbOptions.read_preference = value;
+        dbOptions.readPreference = value;
         break;
       case 'readPreferenceTags':
         // Decode the value
@@ -272,7 +368,9 @@ module.exports = function(url, options) {
       || dbOptions.safe == true)) throw new Error("w set to -1 or 0 cannot be combined with safe/w/journal/fsync")
 
   // If no read preference set it to primary
-  if(!dbOptions.read_preference) dbOptions.read_preference = 'primary';
+  if(!dbOptions.readPreference) {
+    dbOptions.readPreference = 'primary';
+  }
 
   // Add servers to result
   object.servers = servers;

package/lib/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 
-var MongoError = require('mongodb-core').MongoError
+var MongoError = require('mongodb-core').MongoError,
+  f = require('util').format;
 
 var shallowClone = function(obj) {
   var copy = {};
@@ -13,9 +14,9 @@ var getSingleProperty = function(obj, name, value) {
   Object.defineProperty(obj, name, {
     enumerable:true,
     get: function() {
-      return value 
+      return value
     }
-  });  
+  });
 }
 
 var formatSortValue = exports.formatSortValue = function(sortDirection) {
@@ -50,7 +51,7 @@ var formattedOrderClause = exports.formattedOrderClause = function(sortValue) {
         orderBy[sortValue[i]] = 1;
       } else {
         orderBy[sortValue[i][0]] = formatSortValue(sortValue[i][1]);
-      }      
+      }
     }
   } else if(sortValue != null && typeof sortValue == 'object') {
     orderBy = sortValue;
@@ -110,7 +111,7 @@ var toError = function(error) {
   if (error instanceof Error) return error;
 
   var msg = error.err || error.errmsg || error.errMessage || error;
-  var e = new MongoError(msg);
+  var e = MongoError.create({message: msg, driver:true});
 
   // Get all object keys
   var keys = typeof error == 'object'
@@ -137,12 +138,12 @@ var normalizeHintField = function normalizeHintField(hint) {
 
     hint.forEach(function(param) {
       finalHint[param] = 1;
-    });  
+    });
   } else if(hint != null && typeof hint == 'object') {
     finalHint = {};
     for (var name in hint) {
       finalHint[name] = hint[name];
-    }    
+    }
   }
 
   return finalHint;
@@ -230,4 +231,4 @@ exports.normalizeHintField = normalizeHintField;
 exports.handleCallback = handleCallback;
 exports.decorateCommand = decorateCommand;
 exports.isObject = isObject;
-exports.debugOptions = debugOptions;
+exports.debugOptions = debugOptions;

package/mongolabs.js

@@ -0,0 +1,427 @@
+/*
+ * PROPRIETARY AND CONFIDENTIAL
+ *
+ * The contents of this example are proprietary and confidential, and may not be used or distributed without express
+ * written permission from MongoLab.
+ *
+ */
+
+var mongodb = require("mongodb");
+var async = require("async");
+
+var ObjectId = mongodb.ObjectID;
+
+//mongodb.Logger.setLevel("debug");
+var uri = process.env.MONGODB_URI;
+
+function log(s) {
+    console.log(new Date().toISOString() + " " + s);
+}
+
+log("Connecting...");
+mongodb.MongoClient.connect(
+    uri,
+    {
+        replSet: {
+            //poolSize: 10
+            socketOptions: {
+                connectTimeoutMS: 60 * 1000
+            }
+        }
+    },
+    function (err, db) {
+        if (err) {
+            log("Error trying to connect.");
+            log(err.stack);
+        } else {
+            log("Connected.");
+            db.serverConfig.on('joined', function(t, s) {
+                log("joined :: " + t + " :: " + s.name);
+            });
+            db.serverConfig.on('left', function(t, s) {
+                log("joined :: " + t + " :: " + s.name);
+            });
+            db.serverConfig.on('timeout', function(err) {
+                log("timeout :: ");
+                log(err.stack);
+            });
+            log("Running aggregations...");
+            async.forEachOf(
+                aggregations,
+                function (item, i, cb) {
+                    log("Running aggregation " + i + "...");
+                    db.collection(item.collection).aggregate(item.pipeline, function (err, result) {
+                        if (err) {
+                            log("Error running aggregation " + i + ".");
+                            log(err.stack)
+                        } else {
+                            log("Done running aggregation " + i + ".");
+                        }
+                        cb();
+                    });
+                },
+                function (err) {
+                    if (err) {
+                        log("Untrapped error.");
+                        log(err.stack);
+                    } else {
+                        log("Finished running all aggregations.")
+                    }
+                    log("Closing database...");
+                    db.close();
+                }
+            )
+        }
+    }
+);
+
+var aggregations = [
+    // ========== 1 ==========
+    {
+        collection: "tlogs",
+        pipeline: [
+            {
+                "$match": {
+                    "_type": "tlog",
+                    "organization": ObjectId("53eb1ee2e6c77111203d8503"),
+                    "businessDate": {
+                        "$gte": ISODate("2015-11-01T00:00:00.000+0000"),
+                        "$lt": ISODate("2015-11-28T23:59:59.999+0000")
+                    }
+                }
+            },
+            {
+                "$unwind": "$order"
+            },
+            {
+                "$unwind": "$order.orderedOffers"
+            },
+            {
+                "$redact": {
+                    "$cond": {
+                        "if": {
+                            "$not": "$order.orderedOffers.onTheHouse"
+                        },
+                        "then": "$$KEEP",
+                        "else": "$$PRUNE"
+                    }
+                }
+            },
+            {
+                "$redact": {
+                    "$cond": {
+                        "if": {
+                            "$not": "$order.orderedOffers.cancellation"
+                        },
+                        "then": "$$KEEP",
+                        "else": "$$PRUNE"
+                    }
+                }
+            },
+            {
+                "$group": {
+                    "_id": "$order.orderedOffers.offer",
+                    "offer": {
+                        "$first": "$order.orderedOffers.offer"
+                    },
+                    "menu": {
+                        "$first": "$order.orderedOffers.menu"
+                    },
+                    "totalAmount": {
+                        "$sum": "$order.orderedOffers.amount"
+                    },
+                    "totalCount": {
+                        "$sum": NumberInt(1)
+                    },
+                    "totalDiners": {
+                        "$sum": "$diners"
+                    }
+                }
+            }
+        ]
+    },
+    // ========== 2 ==========
+    {
+        collection: "tlogs",
+        pipeline: [
+            {
+                "$match": {
+                    "_type": "tlog",
+                    "organization": ObjectId("53eb1ee2e6c77111203d8503"),
+                    "businessDate": {
+                        "$gte": ISODate("2015-11-01T00:00:00.000+0000"),
+                        "$lt": ISODate("2015-11-28T23:59:59.999+0000")
+                    }
+                }
+            },
+            {
+                "$unwind": "$order"
+            },
+            {
+                "$unwind": "$order.orderedItems"
+            },
+            {
+                "$redact": {
+                    "$cond": {
+                        "if": {
+                            "$not": "$order.orderedItems.onTheHouse"
+                        },
+                        "then": "$$PRUNE",
+                        "else": "$$KEEP"
+                    }
+                }
+            },
+            {
+                "$group": {
+                    "_id": {
+                        "category": "$order.orderedItems.category"
+                    },
+                    "totalItems": {
+                        "$sum": NumberInt(1)
+                    },
+                    "totalAmount": {
+                        "$sum": "$order.orderedItems.price"
+                    }
+                }
+            }
+        ]
+    },
+    // ========== 3 ==========
+    {
+        collection: "tlogs",
+        pipeline: [
+            {
+                "$match": {
+                    "_type": "tlog",
+                    "organization": ObjectId("53eb1ee2e6c77111203d8503"),
+                    "businessDate": {
+                        "$gte": ISODate("2015-11-01T00:00:00.000+0000"),
+                        "$lt": ISODate("2015-11-28T23:59:59.999+0000")
+                    },
+                    "order": {
+                        "$elemMatch": {
+                            "onTheHouse": null
+                        }
+                    }
+                }
+            },
+            {
+                "$unwind": "$order"
+            },
+            {
+                "$unwind": "$order.tips"
+            },
+            {
+                "$project": {
+                    "_id": "$order.tips._id",
+                    "tableTip": {
+                        "$cond": [
+                            {
+                                "$eq": [
+                                    {
+                                        "$size": {
+                                            "$setIntersection": [
+                                                "$order.tableIds",
+                                                [
+                                                    ObjectId("53eb1ee4e6c77111203d852e"),
+                                                    ObjectId("53eb1ee4e6c77111203d852f"),
+                                                    ObjectId("53eb1ee4e6c77111203d8530"),
+                                                    ObjectId("53eb1ee4e6c77111203d8531"),
+                                                    ObjectId("53eb1ee4e6c77111203d8532"),
+                                                    ObjectId("53eb1ee4e6c77111203d8533"),
+                                                    ObjectId("53eb1ee4e6c77111203d8534"),
+                                                    ObjectId("53eb1ee4e6c77111203d8535"),
+                                                    ObjectId("53eb1ee4e6c77111203d8536"),
+                                                    ObjectId("53eb1ee4e6c77111203d8537"),
+                                                    ObjectId("53eb1ee4e6c77111203d8538"),
+                                                    ObjectId("53eb1ee4e6c77111203d8539"),
+                                                    ObjectId("53eb1ee4e6c77111203d853a"),
+                                                    ObjectId("53eb1ee4e6c77111203d853b"),
+                                                    ObjectId("53eb1ee4e6c77111203d853c"),
+                                                    ObjectId("53eb1ee4e6c77111203d853d"),
+                                                    ObjectId("53eb1ee4e6c77111203d853e"),
+                                                    ObjectId("53eb1ee4e6c77111203d853f"),
+                                                    ObjectId("53eb1ee4e6c77111203d8540"),
+                                                    ObjectId("53eb1ee4e6c77111203d8541"),
+                                                    ObjectId("53eb1ee4e6c77111203d8542"),
+                                                    ObjectId("53eb1ee4e6c77111203d8543"),
+                                                    ObjectId("53eb1ee4e6c77111203d8544"),
+                                                    ObjectId("53eb1ee4e6c77111203d8545"),
+                                                    ObjectId("53eb1ee4e6c77111203d8546"),
+                                                    ObjectId("53eb1ee4e6c77111203d8547"),
+                                                    ObjectId("53eb1ee4e6c77111203d8548"),
+                                                    ObjectId("53eb1ee4e6c77111203d8549"),
+                                                    ObjectId("53eb1ee4e6c77111203d854a"),
+                                                    ObjectId("53eb1ee4e6c77111203d854b"),
+                                                    ObjectId("53eb1ee4e6c77111203d854c"),
+                                                    ObjectId("53eb1ee4e6c77111203d854d"),
+                                                    ObjectId("53eb1ee4e6c77111203d854e"),
+                                                    ObjectId("53eb1ee4e6c77111203d854f"),
+                                                    ObjectId("53eb1ee4e6c77111203d8550"),
+                                                    ObjectId("53eb1ee4e6c77111203d8551"),
+                                                    ObjectId("53eb1ee4e6c77111203d8552"),
+                                                    ObjectId("53eb1ee4e6c77111203d8553"),
+                                                    ObjectId("53eb1ee4e6c77111203d8554"),
+                                                    ObjectId("53eb1ee4e6c77111203d8555")
+                                                ]
+                                            ]
+                                        }
+                                    },
+                                    NumberInt(0)
+                                ]
+                            },
+                            false,
+                            true
+                        ]
+                    },
+                    "amount": "$order.tips.amount"
+                }
+            },
+            {
+                "$group": {
+                    "_id": "$tableTip",
+                    "tableTip": {
+                        "$first": "$tableTip"
+                    },
+                    "totalAmount": {
+                        "$sum": "$amount"
+                    },
+                    "totalCount": {
+                        "$sum": NumberInt(1)
+                    }
+                }
+            }
+        ]
+    },
+    // ========== 4 ==========
+    {
+        collection: "tlogs",
+        pipeline: [
+            {
+                "$match": {
+                    "_type": "tlog",
+                    "organization": ObjectId("53eb1ee2e6c77111203d8503"),
+                    "businessDate": {
+                        "$gte": ISODate("2015-11-01T00:00:00.000+0000"),
+                        "$lt": ISODate("2015-11-28T23:59:59.999+0000")
+                    }
+                }
+            },
+            {
+                "$unwind": "$order"
+            },
+            {
+                "$group": {
+                    "_id": {
+                        "orderType": "$order.orderType"
+                    },
+                    "orderType": {
+                        "$first": "$order.orderType"
+                    },
+                    "diners": {
+                        "$sum": "$diners"
+                    },
+                    "totalCount": {
+                        "$sum": NumberInt(1)
+                    }
+                }
+            }
+        ]
+    },
+    // 5, 6, and 7 deleted by Akira just to reduce character count within this JIRA comment.
+    // ========== 8 ==========
+    {
+        collection: "tlogs",
+        pipeline: [
+            {
+                "$match": {
+                    "_type": "tlog",
+                    "organization": ObjectId("53eb1ee2e6c77111203d8503"),
+                    "businessDate": {
+                        "$gte": ISODate("2015-10-01T00:00:00.000+0000"),
+                        "$lt": ISODate("2015-11-28T23:59:59.999+0000")
+                    }
+                }
+            },
+            {
+                "$unwind": "$order"
+            },
+            {
+                "$unwind": "$order.orderedItems"
+            },
+            {
+                "$redact": {
+                    "$cond": {
+                        "if": {
+                            "$and": [
+                                {
+                                    "$not": "$order.orderedItems.cancellation"
+                                },
+                                {
+                                    "$not": "$order.orderedItems.onTheHouse"
+                                }
+                            ]
+                        },
+                        "then": "$$KEEP",
+                        "else": "$$KEEP"
+                    }
+                }
+            },
+            {
+                "$unwind": "$order.orderedItems.selectedModifiers"
+            },
+            {
+                "$group": {
+                    "_id": {
+                        "category": "$order.orderedItems.category"
+                    },
+                    "totalAmount": {
+                        "$sum": "$order.orderedItems.selectedModifiers.price"
+                    }
+                }
+            }
+        ]
+    },
+    // ========== 9 ==========
+    {
+        collection: "tlogs",
+        pipeline: [
+            {
+                "$match": {
+                    "_type": "tlog",
+                    "organization": ObjectId("53eb1ee2e6c77111203d8503"),
+                    "businessDate": {
+                        "$gte": ISODate("2015-10-01T00:00:00.000+0000"),
+                        "$lt": ISODate("2015-11-28T23:59:59.999+0000")
+                    },
+                    "order.orderType": "Refund"
+                }
+            },
+            {
+                "$unwind": "$order"
+            },
+            {
+                "$unwind": "$order.payments"
+            },
+            {
+                "$group": {
+                    "_id": null,
+                    "totalCount": {
+                        "$sum": NumberInt(1)
+                    },
+                    "totalAmount": {
+                        "$sum": "$order.payments.amount"
+                    }
+                }
+            }
+        ]
+    }
+];
+
+function ISODate(x) {
+    return new Date(x);
+}
+
+function NumberInt(x) {
+    return x;
+}