Experimental support for deep create.

Author: jmdobry

karma.start.js

@@ -1,8 +1,8 @@
 beforeEach(function () {
-  localStorage.clear();
-});
+  localStorage.clear()
+})
 
-window.assert = TestRunner.assert;
+window.assert = TestRunner.assert
 
 TestRunner.init({
   features: [],
@@ -11,4 +11,72 @@ TestRunner.init({
   adapterConfig: {
     debug: false
   }
-});
+})
+
+describe('relation functionality', function () {
+  it('nested create', function () {
+    var adapter = this.$$adapter
+    var User = this.$$User
+    return adapter.create(User, {
+      name: 'John',
+      profile: {
+        email: '[email protected]'
+      },
+      posts: [
+        {
+          content: 'foo'
+        }
+      ]
+    }, { with: ['profile', 'post'] }).then(function (user) {
+      // console.log(JSON.stringify(user, null, 2))
+      assert.isDefined(user)
+      assert.isDefined(user.id)
+      assert.isDefined(user.profile)
+      assert.isDefined(user.profile.id)
+      assert.isDefined(user.posts)
+      assert.equal(user.posts.length, 1)
+      assert.isDefined(user.posts[0].id)
+    })
+  })
+  it('nested create many', function () {
+    var adapter = this.$$adapter
+    var User = this.$$User
+    return adapter.createMany(User, [{
+      name: 'John',
+      profile: {
+        email: '[email protected]'
+      },
+      posts: [
+        {
+          content: 'foo'
+        }
+      ]
+    }, {
+      name: 'Sally',
+      profile: {
+        email: '[email protected]'
+      },
+      posts: [
+        {
+          content: 'foo'
+        }
+      ]
+    }], { with: ['profile', 'post'] }).then(function (users) {
+      // console.log(JSON.stringify(users, null, 2))
+      assert.isDefined(users[0])
+      assert.isDefined(users[0].id)
+      assert.isDefined(users[0].profile)
+      assert.isDefined(users[0].profile.id)
+      assert.isDefined(users[0].posts)
+      assert.equal(users[0].posts.length, 1)
+      assert.isDefined(users[0].posts[0].id)
+      assert.isDefined(users[1])
+      assert.isDefined(users[1].id)
+      assert.isDefined(users[1].profile)
+      assert.isDefined(users[1].profile.id)
+      assert.isDefined(users[1].posts)
+      assert.equal(users[1].posts.length, 1)
+      assert.isDefined(users[1].posts[0].id)
+    })
+  })
+})

package.json

@@ -21,13 +21,20 @@
   "standard": {
     "parser": "babel-eslint",
     "globals": [
-      "localStorage"
+      "localStorage",
+      "beforeEach",
+      "describe",
+      "assert",
+      "TestRunner",
+      "it",
+      "JSData",
+      "LocalStorageAdapter"
     ]
   },
   "scripts": {
     "bundle": "webpack --config webpack.config.js --colors",
     "doc": "jsdoc -c conf.json src && node scripts/cleanup.js",
-    "lint": "standard src/**/*.js",
+    "lint": "standard src/**/*.js karma.start.js",
     "min": "uglifyjs dist/js-data-localstorage.js -o dist/js-data-localstorage.min.js --source-map dist/js-data-localstorage.min.map -v -m -c --screw-ie8",
     "version": "node scripts/version.js",
     "banner": "node scripts/banner.js",

src/index.js

@@ -305,6 +305,79 @@ addHiddenPropsToTarget(LocalStorageAdapter.prototype, {
    */
   beforeUpdateMany: noop,
 
+  _create (mapper, props, opts) {
+    const self = this
+    const id = get(props, mapper.idAttribute) || guid()
+    set(props, mapper.idAttribute, id)
+    const key = self.getIdPath(mapper, opts, id)
+
+    // Create the record
+    // TODO: Create related records when the "with" option is provided
+    self.storage.setItem(key, toJson(props))
+    self.ensureId(id, mapper, opts)
+    return fromJson(self.storage.getItem(key))
+  },
+
+  _createWithRelations (mapper, record, opts) {
+    const self = this
+    const fields = {}
+    opts.with || (opts.with = [])
+    const idAttribute = mapper.idAttribute
+    forEachRelation(mapper, opts, function (def, __opts) {
+      const localField = def.localField
+      const relationData = get(record, localField)
+      const relatedMapper = def.getRelation()
+      if (!relationData) {
+        return
+      }
+      if (def.type === 'hasMany') {
+        fields[localField] = relationData
+      } else if (def.type === 'hasOne') {
+        fields[localField] = relationData
+      } else if (def.type === 'belongsTo') {
+        fields[localField] = self._createWithRelations(relatedMapper, relationData, __opts)
+        set(record, def.foreignKey, get(fields[localField], relatedMapper.idAttribute))
+      }
+    })
+    const _props = {}
+    forOwn(record, function (value, key) {
+      if (!(key in fields)) {
+        _props[key] = value
+      }
+    })
+
+    const id = get(_props, idAttribute) || guid()
+    set(_props, idAttribute, id)
+    const key = self.getIdPath(mapper, opts, id)
+
+    // Create the record
+    // TODO: Create related records when the "with" option is provided
+    self.storage.setItem(key, toJson(_props))
+    self.ensureId(id, mapper, opts)
+    record = fromJson(self.storage.getItem(key))
+
+    forEachRelation(mapper, opts, function (def, __opts) {
+      const localField = def.localField
+      const relationData = fields[localField]
+      const relatedMapper = def.getRelation()
+      if (!relationData) {
+        return
+      }
+      if (def.type === 'hasMany') {
+        fields[localField] = relationData.map(function (relatedDataItem) {
+          set(relatedDataItem, def.foreignKey, id)
+          return self._createWithRelations(relatedMapper, relatedDataItem, __opts)
+        })
+      } else if (def.type === 'hasOne') {
+        set(relationData, def.foreignKey, id)
+        fields[localField] = self._createWithRelations(relatedMapper, relationData, __opts)
+      }
+    })
+
+    fillIn(record, fields)
+    return record
+  },
+
   /**
    * Create a new record.
    *
@@ -329,14 +402,7 @@ addHiddenPropsToTarget(LocalStorageAdapter.prototype, {
         return resolve(self[op](mapper, props, opts)).then(function (_props) {
           // Allow for re-assignment from lifecycle hook
           let record = isUndefined(_props) ? props : _props
-          const id = get(record, mapper.idAttribute) || guid()
-          set(record, mapper.idAttribute, id)
-          const key = self.getIdPath(mapper, opts, id)
-
-          // Create the record
-          // TODO: Create related records when the "with" option is provided
-          self.storage.setItem(key, toJson(record))
-          self.ensureId(id, mapper, opts)
+          record = self._createWithRelations(mapper, record, opts)
 
           // afterCreate lifecycle hook
           op = opts.op = 'afterCreate'
@@ -377,16 +443,8 @@ addHiddenPropsToTarget(LocalStorageAdapter.prototype, {
         return resolve(self[op](mapper, props, opts)).then(function (_props) {
           // Allow for re-assignment from lifecycle hook
           let records = isUndefined(_props) ? props : _props
-          const idAttribute = mapper.idAttribute
-
-          // Create the record
-          // TODO: Create related records when the "with" option is provided
-          records.forEach(function (record) {
-            const id = get(record, idAttribute) || guid()
-            set(record, idAttribute, id)
-            const key = self.getIdPath(mapper, opts, id)
-            self.storage.setItem(key, toJson(record))
-            self.ensureId(id, mapper, opts)
+          records = records.map(function (record) {
+            return self._createWithRelations(mapper, record, opts)
           })
 
           // afterCreateMany lifecycle hook