- fix circular dependencies in DataStore

Author: Valodya

src/data/store/index.js

@@ -1,6 +1,6 @@
 import Utils from '../../utils'
 import { deprecated } from '../../decorators'
-import User from '../../users/user'
+import { resolveModelClassFromString } from '../utils'
 
 import { loadRelations, setRelation, addRelation, deleteRelation } from './relations'
 import { bulkCreate, bulkUpdate, bulkDelete } from './bulk'
@@ -9,12 +9,6 @@ import { save } from './save'
 import { remove } from './remove'
 import { getObjectCount } from './count'
 
-const createModelClassFromString = (/** className */) => {
-  //TODO:fix me
-  return function() {
-  }
-}
-
 //TODO: will be removed when remove sync methods
 const namespaceLabel = 'Backendless.Data.of(<ClassName>)'
 
@@ -23,9 +17,7 @@ class DataStore {
   constructor(model) {
     if (Utils.isString(model)) {
       this.className = model
-      this.model = model === User.className
-        ? User
-        : createModelClassFromString(model)
+      this.model = resolveModelClassFromString(this.className)
 
     } else {
       this.className = Utils.getClassName(model)

src/data/store/parse.js

@@ -1,55 +1,79 @@
 import Utils from '../../utils'
+import { resolveModelClassFromString } from '../utils'
 
-//TODO: refactor me
+function isObject(item) {
+  return typeof item === 'object' && item !== null
+}
 
-function formCircDeps(obj) {
+function parseCircularDependencies(obj) {
   const result = new obj.constructor()
-  const circDepsIDs = {}
-  const iteratedObjects = []
+  const subIds = {}
+  const postAssign = []
+  const iteratedItems = []
 
-  const _formCircDepsHelper = (obj, res) => {
-    if (iteratedObjects.indexOf(obj) === -1) {
-      iteratedObjects.push(obj)
+  function ensureCircularDep(source, target, prop) {
+    if (subIds[source[prop].__originSubID]) {
+      target[prop] = subIds[source[prop].__originSubID]
+    } else {
+      postAssign.push([target, prop, source[prop].__originSubID])
+    }
+  }
 
-      if (obj.hasOwnProperty('__subID')) {
-        circDepsIDs[obj['__subID']] = res
-        delete obj['__subID']
-      }
+  function processModel(source, target, prop) {
+    const Model = resolveModelClassFromString(source[prop].___class) || source[prop].constructor
+
+    target[prop] = new Model()
+
+    if (source[prop].__subID) {
+      subIds[source[prop].__subID] = target[prop]
+      delete source[prop].__subID
+    }
+  }
+
+  function buildCircularDeps(source, target) {
+    if (iteratedItems.indexOf(source) === -1) {
+      iteratedItems.push(source)
+
+      for (const prop in source) {
+        if (source.hasOwnProperty(prop)) {
+          if (Array.isArray(source[prop])) {
+            buildCircularDeps(source[prop], target[prop] = [])
+
+          } else if (isObject(source[prop])) {
+            if (source[prop].__originSubID) {
+              ensureCircularDep(source, target, prop)
 
-      for (const prop in obj) {
-        if (obj.hasOwnProperty(prop)) {
-          if (typeof obj[prop] === 'object' && obj[prop] != null) {
-            if (obj[prop].hasOwnProperty('__originSubID')) {
-              res[prop] = circDepsIDs[obj[prop]['__originSubID']]
             } else {
-              res[prop] = new (obj[prop].constructor)()
-              _formCircDepsHelper(obj[prop], res[prop])
+              processModel(source, target, prop)
+
+              buildCircularDeps(source[prop], target[prop])
             }
+
           } else {
-            res[prop] = obj[prop]
+            target[prop] = source[prop]
           }
         }
       }
     }
   }
 
-  _formCircDepsHelper(obj, result)
+  buildCircularDeps(obj, result)
+
+  postAssign.forEach(([target, prop, __originSubID]) => target[prop] = subIds[__originSubID])
 
   return result
 }
 
 export function parseFindResponse(response, Model) {
-  Model = Utils.isFunction(Model) ? Model : undefined
-
   const sanitizeResponseItem = resp => {
-    const item = Model ? new Model() : {}
+    Model = Utils.isFunction(Model) ? Model : resolveModelClassFromString(resp.___class)
 
-    return Utils.deepExtend(item, resp.fields || resp)
+    return Utils.deepExtend(new Model(), resp.fields || resp)
   }
 
   const result = Utils.isArray(response)
     ? response.map(sanitizeResponseItem)
     : sanitizeResponseItem(response)
 
-  return formCircDeps(result)
+  return parseCircularDependencies(result)
 }

src/data/utils.js

@@ -0,0 +1,10 @@
+import User from '../users/user'
+
+export function resolveModelClassFromString (className) {
+  if(className === User.className){
+    return User
+  }
+
+  return function() {
+  }
+}

test/e2e/specs/user-relations.js

@@ -0,0 +1,104 @@
+import '../helpers/global'
+import sandbox from '../helpers/sandbox'
+
+const Backendless = sandbox.Backendless
+
+describe('User - Relations', function() {
+  let consoleApi
+  let appId
+
+  sandbox.forTest()
+
+  const createRelationColumn = (tableName, columnName, toTableName, relationshipType) => {
+    return consoleApi.tables.createColumn(appId, { name: tableName }, {
+      dataType: 'DATA_REF',
+      name    : columnName,
+      toTableName,
+      relationshipType
+    })
+  }
+
+  beforeEach(function() {
+    consoleApi = this.consoleApi
+    appId = this.app.id
+  })
+
+  it('Circular Users relations', function() {
+    const usersStore = Backendless.Data.of(Backendless.User)
+
+    let user1 = { email: 'user1@com', password: '123456' }
+    let user2 = { email: 'user2@com', password: '123456' }
+    let user3 = { email: 'user3@com', password: '123456' }
+    let user4 = { email: 'user4@com', password: '123456' }
+    let user5 = { email: 'user5@com', password: '123456' }
+    let user6 = { email: 'user6@com', password: '123456' }
+
+    return Promise.resolve()
+      .then(() => {
+        return Promise.resolve()
+          .then(() => usersStore.save(user1))
+          .then(() => usersStore.save(user2))
+          .then(() => usersStore.save(user3))
+          .then(() => usersStore.save(user4))
+          .then(() => usersStore.save(user5))
+          .then(() => usersStore.save(user6))
+          .then(() => usersStore.find(Backendless.DataQueryBuilder.create().setSortBy('created')))
+      })
+      .then(users => {
+        user1 = users[0]
+        user2 = users[1]
+        user3 = users[2]
+        user4 = users[3]
+        user5 = users[4]
+        user6 = users[5]
+      })
+      .then(() => {
+        return Promise.all([
+          createRelationColumn('Users', 'friends', 'Users', 'ONE_TO_MANY'),
+          createRelationColumn('Users', 'blocked', 'Users', 'ONE_TO_MANY'),
+        ])
+      })
+      .then(() => {
+        return Promise.all([
+          usersStore.addRelation(user1.objectId, 'friends', [user2, user3, user6]),
+          usersStore.addRelation(user1.objectId, 'blocked', [user2, user3, user4, user5]),
+        ])
+      })
+      .then(() => {
+        const query = Backendless.DataQueryBuilder
+          .create()
+          .setWhereClause(`objectId = '${user1.objectId}'`)
+          .setRelated(['friends', 'blocked'])
+          .setSortBy('created')
+
+        return Backendless.Data.of('Users').find(query)
+      })
+      .then(users => {
+        expect(users[0].objectId).to.be.equal(user1.objectId)
+
+        expect(users[0].friends.length).to.be.equal(3)
+        expect(users[0].blocked.length).to.be.equal(4)
+
+        const friendsUser2 = users[0].friends.find(o => o.objectId === user2.objectId)
+        const friendsUser3 = users[0].friends.find(o => o.objectId === user3.objectId)
+        const friendsUser6 = users[0].friends.find(o => o.objectId === user6.objectId)
+
+        const blockedUser2 = users[0].blocked.find(o => o.objectId === user2.objectId)
+        const blockedUser3 = users[0].blocked.find(o => o.objectId === user3.objectId)
+        const blockedUser4 = users[0].blocked.find(o => o.objectId === user4.objectId)
+        const blockedUser5 = users[0].blocked.find(o => o.objectId === user5.objectId)
+
+        expect(friendsUser2.objectId).to.be.equal(user2.objectId)
+        expect(friendsUser3.objectId).to.be.equal(user3.objectId)
+        expect(friendsUser6.objectId).to.be.equal(user6.objectId)
+
+        expect(blockedUser2.objectId).to.be.equal(user2.objectId)
+        expect(blockedUser3.objectId).to.be.equal(user3.objectId)
+        expect(blockedUser4.objectId).to.be.equal(user4.objectId)
+        expect(blockedUser5.objectId).to.be.equal(user5.objectId)
+
+        expect(friendsUser2).to.be.equal(blockedUser2)
+        expect(friendsUser3).to.be.equal(blockedUser3)
+      })
+  })
+})