Merge pull request #284 from davincho/temporary-entites

Support for temporary items

Author: jmdobry

src/datastore/async_methods/create.js

@@ -20,6 +20,7 @@ module.exports = function create (resourceName, attrs, options) {
   let _this = this
   let DSUtils = _this.utils
   let definition = _this.definitions[resourceName]
+  let resource = _this.store[resourceName]
   let adapter
 
   options = options || {}
@@ -32,7 +33,7 @@ module.exports = function create (resourceName, attrs, options) {
     rejectionError = DSUtils._oErr('attrs')
   } else {
     options = DSUtils._(definition, options)
-    if (options.upsert && DSUtils._sn(attrs[definition.idAttribute])) {
+    if (options.upsert && DSUtils._sn(attrs[definition.idAttribute]) && !resource.temporaryItems[attrs[definition.idAttribute]]) {
       return _this.update(resourceName, attrs[definition.idAttribute], attrs, options)
     }
     options.logFn('create', attrs, options)

src/datastore/index.js

@@ -155,6 +155,8 @@ function like (pattern, flags) {
 }
 
 defaultsPrototype.defaultFilter = function (collection, resourceName, params, options) {
+  let idA = this.definitions[resourceName].idAttribute
+  let resource = this.store[resourceName]
   let filtered = collection
   let where = null
   let reserved = {
@@ -193,6 +195,11 @@ defaultsPrototype.defaultFilter = function (collection, resourceName, params, op
     filtered = DSUtils.filter(filtered, function (attrs) {
       let first = true
       let keep = true
+
+      if (options.excludeTemporary && resource.temporaryItems[attrs[idA]]) {
+        return false
+      }
+
       DSUtils.forOwn(where, function (clause, field) {
         if (!DSUtils._o(clause)) {
           clause = {
@@ -259,8 +266,13 @@ defaultsPrototype.defaultFilter = function (collection, resourceName, params, op
           first = false
         })
       })
+
       return keep
     })
+  } else if (options.excludeTemporary) {
+    filtered = DSUtils.filter(filtered, function (attrs) {
+      return resource.temporaryItems[attrs[idA]]
+    })
   }
 
   let orderBy = null

src/datastore/sync_methods/defineResource.js

@@ -25,6 +25,7 @@ let instanceMethods = [
   'changes',
   'commit',
   'hasChanges',
+  'isNew',
   'lastModified',
   'lastSaved',
   'previous',
@@ -269,7 +270,8 @@ module.exports = function defineResource (definition) {
       observers: {},
       changeHistories: {},
       changeHistory: [],
-      collectionModified: 0
+      collectionModified: 0,
+      temporaryItems: {}
     }
 
     let resource = _this.store[def.name]

src/datastore/sync_methods/index.js

@@ -330,6 +330,18 @@ export default {
   },
   inject: require('./inject'),
 
+  // Return whether the item with the given primary key is a temporary item.
+  //
+  // @param resourceName The name of the type of resource of the item.
+  // @param id The primary key of the item.
+  // @returns Whether the item with the given primary key is a temporary item.
+  isNew (resourceName, id) {
+    let {_this, _resourceName, _id} = check.call(this, 'isNew', resourceName, id || fakeId)
+    let resource = _this.store[_resourceName]
+
+    return !!resource.temporaryItems[_id]
+  },
+
   // Return the timestamp from the last time the item with the given primary key was changed.
   //
   // @param resourceName The name of the type of resource of the item.

src/datastore/sync_methods/inject.js

@@ -134,6 +134,8 @@ function _inject (definition, resource, attrs, options) {
         args.push(attrs[dep])
       })
       attrs[idA] = c[idA][c[idA].length - 1].apply(attrs, args)
+    } else if (options.temporary) {
+      attrs[idA] = DSUtils.guid()
     }
 
     if (!(idA in attrs)) {
@@ -234,6 +236,10 @@ function _inject (definition, resource, attrs, options) {
           _react.call(item, {}, {}, {}, null, true)
           // save "previous" attributes of the injected item, for change diffs later
           resource.previousAttributes[id] = DSUtils.copy(item, null, null, null, definition.relationFields)
+          // mark item as temporary if guid has been generated
+          if (options.temporary) {
+            resource.temporaryItems[id] = true
+          }
         } else {
           // item is being re-injected
           // new properties take precedence

src/utils.js

@@ -19,6 +19,7 @@ let upperCase = require('mout/string/upperCase')
 let get = require('mout/object/get')
 let set = require('mout/object/set')
 let observe = require('../lib/observe-js/observe.js')
+let guid = require('mout/random/guid')
 let w, P, File
 let objectProto = Object.prototype
 let toString = objectProto.toString
@@ -498,6 +499,7 @@ export default {
     return isString(json) ? JSON.parse(json) : json
   },
   get,
+  guid,
   intersection,
   isArray,
   isBlacklisted,

test/both/datastore/sync_methods/filter.test.js

@@ -564,5 +564,16 @@ describe('DS#filter', function () {
     assert.deepEqual(User.filter({ where: { name: { notLike: 'foo%foo' } } }), [users[0], users[1], users[2], users[3], users[4], users[5], users[6], users[9]]);
     assert.deepEqual(User.filter({ where: { name: { notLike: 'foo_foo' } } }), [users[0], users[1], users[2], users[3], users[4], users[5], users[6], users[7], users[9]]);
     assert.deepEqual(User.filter({ where: { name: { notLike: 'foo%foo_' } } }), [users[0], users[1], users[2], users[3], users[4], users[5], users[6], users[7], users[8]]);
-  })
+  });
+  it('should include temporary items when `excludeTemporary` is false', function() {
+    var user1 = User.inject({ name: 'foo' }, {temporary: true});
+    var user2 = User.inject({ id: 2, name: 'foo' });
+
+    assert(User.filter().length == 2);
+    assert(User.filter(null, {excludeTemporary: false}).length == 2);
+    assert(User.filter(null, {excludeTemporary: true}).length == 1);
+
+    assert(User.filter({name: 'foo'}, {excludeTemporary: true}).length == 1);
+    assert(User.filter({name: 'foo'}, {excludeTemporary: false}).length == 2);
+  });
 });

test/both/datastore/sync_methods/inject.test.js

@@ -487,4 +487,53 @@ describe('DS#inject', function () {
     ], 'bars should have been injected, but not linked');
     assert.equal(Bar.getAll().length, 3, '3 bars should be in the store');
   });
+  it('should inject temporary item', function() {
+    var Foo = store.defineResource({
+      name: 'foo',
+      idAttribute: 'foo_id'
+    });
+
+    var foo = Foo.inject({bar: 'bar'}, {temporary: true});
+
+    assert(foo.foo_id != null);
+  });
+  it('should replace temporary item with real item from server, conserving any relations to other items', function() {
+    delete user1.id;
+
+    // Create item and related items referencing temporary ID
+    var user = store.inject('user', user1, {temporary: true});
+    var comment = {
+      id: 2,
+      approvedBy: user.id,
+      content: 'test comment 2'
+    };
+    var profile = {
+        author: 'John',
+        age: 30,
+        id: 5,
+        userId: user.id
+    };
+
+    // belongsTo relation
+    store.inject('organization', organization2);
+    assert.deepEqual(JSON.stringify(user.organization), JSON.stringify(organization2));
+
+    // hasMany relation
+    store.inject('comment', comment);
+    assert.deepEqual(JSON.stringify(user.comments[0]), JSON.stringify(comment));
+
+    // hasOne relation
+    store.inject('profile', profile);
+    assert.deepEqual(JSON.stringify(user.profile), JSON.stringify(profile));
+
+    // Inject item with real ID, replacing guid
+    var guid = user.id;
+    profile.userId = comment.approvedBy = user.id = 10;
+    user = store.inject('user', user, {replacingId: guid});
+
+    assert.deepEqual(JSON.stringify(user.organization), JSON.stringify(organization2));
+    assert.deepEqual(JSON.stringify(user.comments[0]), JSON.stringify(comment));
+    assert.deepEqual(JSON.stringify(user.profile), JSON.stringify(profile));
+
+  });
 });

test/both/datastore/sync_methods/isNew.test.js

@@ -0,0 +1,15 @@
+describe('DS#isNew', function () {
+  it('should return true for temporary instances', function () {
+    var user = store.inject('user', {
+      foo: 'foo'
+    }, {
+      temporary: true
+    });
+
+    assert.ok(user.DSIsNew());
+  });
+  it('should return false for `real` instances', function() {
+    var user = store.inject('user', user1);
+    assert.notOk(user.DSIsNew());
+  });
+});

test/browser/datastore/async_methods/create.test.js

@@ -270,4 +270,28 @@ describe('DS#create', function () {
       assert.deepEqual(JSON.stringify(Foo.get(1)), JSON.stringify({ first: 'John', last: 'Anderson', id: 1, fullName: 'John Anderson' }));
     });
   });
+  it('should create an temporary item with guid', function () {
+    var Foo = store.defineResource({
+      name: 'foo',
+      idAttribute: 'foo_id'
+    });
+
+    var _this = this;
+    var foo = Foo.inject({bar: 'bar'}, {temporary: true});
+    var data = JSON.stringify(foo);
+
+    setTimeout(function () {
+      assert.equal(1, _this.requests.length);
+      assert.equal(_this.requests[0].url, 'http://test.js-data.io/foo');
+      assert.equal(_this.requests[0].method, 'POST');
+      assert.equal(_this.requests[0].requestBody, data);
+      _this.requests[0].respond(200, { 'Content-Type': 'application/json' }, DSUtils.toJson({ name: 'foo', foo_id: 2 }));
+    }, 100);
+
+    return Foo.create(foo).then(function (f) {
+      assert.deepEqual(JSON.stringify(f), JSON.stringify({ name: 'foo', foo_id: 2 }), 'foo 1 should have been created');
+      assert.deepEqual(JSON.stringify(Foo.get(2)), JSON.stringify({ name: 'foo', foo_id: 2}));
+      assert(Foo.get(foo.foo_id) == null, 'Temporary ID should have been overwritten');
+    });
+  });
 });