feat(saveAll): allow saving an array of ids (#20)

* feat(saveAll): allow saving an array of ids

Author: gjuchault

README.md

@@ -174,6 +174,22 @@ user.saveAll({
 })
 ```
 
+You can also save an array of ids with hasMany or belongsToMany:
+
+```js
+user.role = roleA
+user.rights = [ rightA.id, rightB.id ]
+
+user.saveAll({
+  role: true,
+  rights: true
+})
+```
+
+Note: be careful that user.rights will be repopulated with rightA and rightB, but those objects will not
+be the same as the original rightA and rightB.
+That means `rightA.User_id` is undefined (because saveAll knows nothing about it), but `user.rights[0].User_id` will be set.
+
 Tree has the same possibilities that you have in `embed`
 
 ### pivot data

lib/model/saveAll.belongsToMany.js

@@ -1,12 +1,13 @@
 const debug = require('debug')('requelize:model:saveAll')
 const generateJoinId = require('./util/generateJoinId')
 
-function baseSaveAll (Model, inst, requelize, key, join, RelModel, subTree, subInst) {
+function baseSaveAll (Model, inst, requelize, key, join, RelModel, subTree, subInst_) {
   debug(`saving belongsToMany ${Model._name}:${key} -> ${RelModel._name}`)
-  subInst = new RelModel(subInst)
+  const subInst = (typeof subInst_ === 'string') ? RelModel.get(subInst_) : Promise.resolve(new RelModel(subInst_))
 
-  return subInst.saveAll(subTree)
-    .then(() => {
+  return subInst
+    .then(subInst => subInst.saveAll(subTree))
+    .then((subInst) => {
       const joinId = generateJoinId(Model, RelModel, inst, subInst)
       const joinRel = new join.JoinModel({
         id: joinId,

lib/model/saveAll.js

@@ -49,19 +49,21 @@ module.exports = function (Model, inst, requelize, tree) {
       // hasMany
       if (Array.isArray(inst[join.field])) {
         debug(`saving hasMany ${Model._name}:${key} -> ${RelModel._name}`)
-        return Promise
-          .all(
-            inst[join.field].map((subInst) => {
-              subInst = new RelModel(subInst)
 
+        const saverInstsOrIds = inst[join.field].map((subInst) => {
+          return (typeof subInst === 'string') ? RelModel.get(subInst) : Promise.resolve(new RelModel(subInst))
+        })
+
+        return Promise
+          .all(saverInstsOrIds)
+          .then((subInsts) => {
+            return Promise.all(subInsts.map(subInst => {
               debug(`adding ${Model._name}:${join.foreignKey} = ${RelModel._name}:${RelModel._options.primaryKey}`)
               subInst[join.foreignKey] = inst[Model._options.primaryKey]
 
-              return subInst
-                .saveAll(subTree)
-                .then(() => subInst)
-            })
-          )
+              return subInst.saveAll(subTree)
+            }))
+          })
           .then((subInsts) => {
             inst[join.field] = subInsts
           })

package.json

@@ -1,6 +1,6 @@
 {
   "name": "requelize",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "RethinkDB ORM",
   "main": "index.js",
   "repository": "https://github.com/buckless/requelize.git",

test/test.pivot.js

@@ -38,6 +38,7 @@ test('instance - pivot', (t) => {
       t.equal('pivot', res[0].bars[0].getPivot().data, 'has pivot data')
     })
     .catch((err) => {
+      console.log(err)
       t.fail(err)
     })
     .then(() => {

test/test.saveAll.js

@@ -94,6 +94,78 @@ test('instance - saveAll', (t) => {
     })
 })
 
+test('instance - saveAll with ids only', (t) => {
+  t.plan(6)
+
+  let Foo
+  let Baz
+  let Boz
+  let foo
+  let baz
+  let boz
+
+  dropDb()
+    .then(() => {
+      Foo = requelize.model('foo', {
+        name: Joi.string()
+      })
+
+      Baz = requelize.model('baz', {
+        name: Joi.string()
+      })
+
+      Boz = requelize.model('boz', {
+        name: Joi.string()
+      })
+
+      Foo.hasMany('baz', 'bazes', 'foo_id')
+      Baz.belongsTo('foo', 'foo', 'foo_id')
+
+      Foo.belongsToMany('boz', 'bozes')
+      Boz.belongsToMany('foo', 'foos')
+
+      return requelize.sync()
+    })
+    .then(() => {
+      baz = new Baz({ name: 'baz' })
+      boz = new Boz({ name: 'boz' })
+
+      return Promise.all([ baz.save(), boz.save() ])
+    })
+    .then(() => {
+      foo = new Foo({ name: 'foo' })
+
+      foo.bazes = [ baz.id ]
+      foo.bozes = [ boz.id ]
+
+      return foo.saveAll({
+        bazes: true,
+        bozes: true
+      })
+    })
+    .then(() => {
+      t.equal('string', typeof foo.id, 'foo is saved')
+      t.equal('string', typeof baz.id, 'baz is saved')
+      t.equal('string', typeof boz.id, 'boz is saved')
+
+      // Be careful here : foo.bazes[0] is not the same object as baz because it was recreated from the id
+      // That means baz.foo_id will be undefined whereas foo.bazes[0].foo_id is set
+      t.equal(foo.id, foo.bazes[0].foo_id, 'hasMany relationship')
+
+      return Foo.embed({ bozes: true })
+    })
+    .then((res) => {
+      t.equal(true, Array.isArray(res[0].bozes), 'belongsToMany relationship')
+      t.equal(1, res[0].bozes.length, 'belongsToMany relationship')
+    })
+    .catch((err) => {
+      t.fail(err)
+    })
+    .then(() => {
+      t.end()
+    })
+})
+
 test('instance - resave', (t) => {
   t.plan(2)