1.9

.gitignore

@@ -11,3 +11,4 @@
 *.swp
 *.swo
 node_modules
+dist

CHANGES.md

@@ -0,0 +1,29 @@
+# Breaking Changes
+
+# 1.9
+
+## Remote Method API
+
+`loopback.remoteMethod()` is now deprecated.
+
+Defining remote methods now should be done like this:
+
+```js
+// static
+MyModel.greet = function(msg, cb) {
+  cb(null, 'greetings... ' + msg);
+}
+
+MyModel.remoteMethod(
+  'greet',
+  {
+    accepts: [{arg: 'msg', type: 'string'}],
+    returns: {arg: 'greeting', type: 'string'}
+  }
+);
+```
+
+**NOTE: remote instance method support is also now deprecated...
+Use static methods instead. If you absolutely need it you can still set
+`options.isStatic = false`** We plan to drop support for instance methods in
+`2.0`.

Gruntfile.js

@@ -143,7 +143,8 @@ module.exports = function(grunt) {
 
           // list of files / patterns to load in the browser
           files: [
-            'test/e2e/remote-connector.e2e.js'
+            'test/e2e/remote-connector.e2e.js',
+            'test/e2e/replication.e2e.js'
           ],
 
           // list of files to exclude

docs.json

@@ -13,6 +13,9 @@
     "lib/models/data-model.js",
     "lib/models/role.js",
     "lib/models/user.js",
+    "lib/models/change.js",
+    "docs/api-datasource.md",
+    "docs/api-geopoint.md",
     "docs/api-model.md",
     "docs/api-model-remote.md"
   ],

example/replication/app.js

@@ -0,0 +1,138 @@
+var loopback = require('../../');
+var app = loopback();
+var db = app.dataSource('db', {connector: loopback.Memory});
+var Color = app.model('color', {dataSource: 'db', options: {trackChanges: true}});
+var Color2 = app.model('color2', {dataSource: 'db', options: {trackChanges: true}});
+var target = Color2;
+var source = Color;
+var SPEED = process.env.SPEED || 100;
+var conflicts;
+
+var steps = [
+
+  createSomeInitialSourceData,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data'),
+    list.bind(this, target, 'current TARGET data'),
+
+  updateSomeTargetData,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data '),
+    list.bind(this, target, 'current TARGET data (includes conflicting update)'),
+
+  updateSomeSourceDataCausingAConflict,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data (now has a conflict)'),
+    list.bind(this, target, 'current TARGET data (includes conflicting update)'),
+
+  resolveAllConflicts,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data (conflict resolved)'),
+    list.bind(this, target, 'current TARGET data (conflict resolved)'),
+
+  createMoreSourceData,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data'),
+    list.bind(this, target, 'current TARGET data'),
+
+  createEvenMoreSourceData,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data'),
+    list.bind(this, target, 'current TARGET data'),
+
+  deleteAllSourceData,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data (empty)'),
+    list.bind(this, target, 'current TARGET data (empty)'),
+
+  createSomeNewSourceData,
+
+    replicateSourceToTarget,
+    list.bind(this, source, 'current SOURCE data'),
+    list.bind(this, target, 'current TARGET data')
+];
+
+run(steps);
+
+function createSomeInitialSourceData() {
+  Color.create([
+    {name: 'red'},
+    {name: 'blue'},
+    {name: 'green'}
+  ]);
+}
+
+function replicateSourceToTarget() {
+  Color.replicate(0, Color2, {}, function(err, replicationConflicts) {
+    conflicts = replicationConflicts;
+  });
+}
+
+function resolveAllConflicts() {
+  if(conflicts.length) {
+    conflicts.forEach(function(conflict) {
+      conflict.resolve();
+    });
+  }
+}
+
+function updateSomeTargetData() {
+  Color2.findById(1, function(err, color) {
+    color.name = 'conflict';
+    color.save();
+  });
+}
+
+function createMoreSourceData() {
+  Color.create({name: 'orange'});
+}
+
+function createEvenMoreSourceData() {
+  Color.create({name: 'black'});
+}
+
+function updateSomeSourceDataCausingAConflict() {
+  Color.findById(1, function(err, color) {
+    color.name = 'red!!!!';
+    color.save();
+  });
+}
+
+function deleteAllSourceData() {
+  Color.destroyAll();
+}
+
+function createSomeNewSourceData() {
+  Color.create([
+    {name: 'violet'},
+    {name: 'amber'},
+    {name: 'olive'}
+  ]);
+}
+
+function list(model, msg) {
+  console.log(msg);
+  model.find(function(err, items) {
+    items.forEach(function(item) {
+      console.log(' -', item.name);
+    });
+    console.log();
+  });
+}
+
+function run(steps) {
+  setInterval(function() {
+    var step = steps.shift();
+    if(step) {
+      console.log(step.name);
+      step();
+    }
+  }, SPEED);
+}

lib/application.js

@@ -108,7 +108,9 @@ app.model = function (Model, config) {
     assert(typeof Model === 'function', 'app.model(Model) => Model must be a function / constructor');
     assert(Model.modelName, 'Model must have a "modelName" property');
     var remotingClassName = compat.getClassNameForRemoting(Model);
-    this.remotes().exports[remotingClassName] = Model;
+    if(Model.sharedClass) {
+      this.remotes().addClass(Model.sharedClass);
+    }
     this.models().push(Model);
     clearHandlerCache(this);
     Model.shared = true;
@@ -205,14 +207,9 @@ app.dataSource = function (name, config) {
 
 app.remoteObjects = function () {
   var result = {};
-  var models = this.models();
-
-  // add in models
-  models.forEach(function (ModelCtor) {
-    // only add shared models
-    if(ModelCtor.shared && typeof ModelCtor.sharedCtor === 'function') {
-      result[compat.getClassNameForRemoting(ModelCtor)] = ModelCtor;
-    }
+
+  this.remotes().classes().forEach(function(sharedClass) {
+    result[sharedClass.name] = sharedClass.ctor;
   });
 
   return result;

lib/connectors/base-connector.js

@@ -51,4 +51,4 @@ Connector._createJDBAdapter = function (jdbModule) {
 
 Connector.prototype._addCrudOperationsFromJDBAdapter = function (connector) {
 
-}
+}

lib/connectors/memory.js

@@ -36,4 +36,4 @@ inherits(Memory, Connector);
  * JugglingDB Compatibility
  */
 
-Memory.initialize = JdbMemory.initialize;
+Memory.initialize = JdbMemory.initialize;

lib/connectors/remote.js

@@ -2,9 +2,10 @@
  * Dependencies.
  */
 
-var assert = require('assert')
-  , compat = require('../compat')
-  , _ = require('underscore');
+var assert = require('assert');
+var remoting = require('strong-remoting');
+var compat = require('../compat');
+var DataAccessObject = require('loopback-datasource-juggler/lib/dao');
 
 /**
  * Export the RemoteConnector class.
@@ -24,21 +25,25 @@ function RemoteConnector(settings) {
   this.root = settings.root || '';
   this.host = settings.host || 'localhost';
   this.port = settings.port || 3000;
+  this.remotes = remoting.create();
+
+  // TODO(ritch) make sure this name works with Model.getSourceId()
+  this.name = 'remote-connector';
 
   if(settings.url) {
     this.url = settings.url;
   } else {
     this.url = this.protocol + '://' + this.host + ':' + this.port + this.root;
   }
 
-  // handle mixins here
-  this.DataAccessObject = function() {};
+  // handle mixins in the define() method
+  var DAO = this.DataAccessObject = function() {};
 }
 
 RemoteConnector.prototype.connect = function() {
+  this.remotes.connect(this.url, this.adapter);
 }
 
-
 RemoteConnector.initialize = function(dataSource, callback) {
   var connector = dataSource.connector = new RemoteConnector(dataSource.settings);
   connector.connect();
@@ -47,22 +52,40 @@ RemoteConnector.initialize = function(dataSource, callback) {
 
 RemoteConnector.prototype.define = function(definition) {
   var Model = definition.model;
-  var className = compat.getClassNameForRemoting(Model);
-  var url = this.url;
-  var adapter = this.adapter;
-
-  Model.remotes(function(err, remotes) {
-    var sharedClass = getSharedClass(remotes, className);
-    remotes.connect(url, adapter);
-    sharedClass
-      .methods()
-      .forEach(Model.createProxyMethod.bind(Model));
-  });
+  var remotes = this.remotes;
+  var SharedClass;
+
+  assert(Model.sharedClass, 'cannot attach ' + Model.modelName
+    + ' to a remote connector without a Model.sharedClass');
+
+  remotes.addClass(Model.sharedClass);
+
+  Model
+    .sharedClass
+    .methods()
+    .forEach(function(remoteMethod) {
+      // TODO(ritch) more elegant way of ignoring a nested shared class
+      if(remoteMethod.name !== 'Change'
+        && remoteMethod.name !== 'Checkpoint') {
+        createProxyMethod(Model, remotes, remoteMethod);
+      }
+    });
 }
 
-function getSharedClass(remotes, className) {
-  return _.find(remotes.classes(), function(sharedClass) {
-    return sharedClass.name === className;
-  });
+function createProxyMethod(Model, remotes, remoteMethod) {
+  var scope = remoteMethod.isStatic ? Model : Model.prototype;
+  var original = scope[remoteMethod.name];
+
+  scope[remoteMethod.name] = function remoteMethodProxy() {
+    var args = Array.prototype.slice.call(arguments);
+    var lastArgIsFunc = typeof args[args.length - 1] === 'function';
+    var callback;
+    if(lastArgIsFunc) {
+      callback = args.pop();
+    }
+
+    remotes.invoke(remoteMethod.stringName, args, callback);
+  }
 }
+
 function noop() {}

lib/loopback.js

@@ -155,7 +155,7 @@ loopback.createModel = function (name, properties, options) {
     BaseModel = loopback.getModel(BaseModel);
   }
 
-  BaseModel = BaseModel || loopback.Model;
+  BaseModel = BaseModel || loopback.DataModel;
 
   var model = BaseModel.extend(name, properties, options);
 
@@ -320,6 +320,7 @@ loopback.Role = require('./models/role').Role;
 loopback.RoleMapping = require('./models/role').RoleMapping;
 loopback.ACL = require('./models/acl').ACL;
 loopback.Scope = require('./models/acl').Scope;
+loopback.Change = require('./models/change');
 
 /*!
  * Automatically attach these models to dataSources

lib/models/acl.js

@@ -91,7 +91,7 @@ var ACLSchema = {
  * @inherits Model
  */
 
-var ACL = loopback.createModel('ACL', ACLSchema);
+var ACL = loopback.DataModel.extend('ACL', ACLSchema);
 
 ACL.ALL = AccessContext.ALL;
 

lib/models/application.js

@@ -113,7 +113,7 @@ function generateKey(hmacKey, algorithm, encoding) {
  * @inherits {Model}
  */
 
-var Application = loopback.createModel('Application', ApplicationSchema);
+var Application = loopback.DataModel.extend('Application', ApplicationSchema);
 
 /*!
  * A hook to generate keys before creation