feat/fix: Disperse moduleName and Type for relationsships

Author: salisdemos

src/module/ModuleBuilder.js

@@ -180,8 +180,8 @@ export class ModuleBuilder {
       const relatedObjectMethods = this.apiMethods.related[relatedObjectType]
 
       if (relatedObjectMethods.isCollection()) {
-        const listActionName = `listRelated${relatedObjectType}`
-        relatedActions[listActionName] = listRelatedAction(this.api, this.moduleName, relatedObjectType)
+        const listActionName = `listRelated${relatedObjectTypeActionName}`
+        relatedActions[listActionName] = listRelatedAction(this.api, this.moduleName, relatedObjectTypeActionName)
       }
     }
 

src/module/resource/ResourceBuilder.js

@@ -69,25 +69,25 @@ export class ResourceBuilder {
           isToMany: relatedObject.data.constructor === Array
         }
 
-        relatedObject.get = getRelationship(this.store, relatedObject, relationshipConfig)
-        relatedObject.load = loadRelationship(this.store, obj.id, obj.type, relatedObject, relationshipConfig)
+        relatedObject.get = getRelationship(this.store, currentRelationshipName, relatedObject, relationshipConfig)
+        relatedObject.load = loadRelationship(this.store, obj.id, currentRelationshipName, relatedObject, relationshipConfig)
 
         if (relationshipConfig.isToMany) {
-          relatedObject.list = listRelationship(this.store, relatedObject)
+          relatedObject.list = listRelationship(this.store, currentRelationshipName, relatedObject)
         }
 
         relationships[currentRelationshipName] = relatedObject
       }
 
       // shorthand variant
       obj.loadRel = (relationshipName) => {
-        return loadRelationship(this.store, obj.id, obj.type, relationships[relationshipName], getRelationshipConfig(relationships[relationshipName]))()
+        return loadRelationship(this.store, obj.id, relationshipName, relationships[relationshipName], getRelationshipConfig(relationships[relationshipName]))()
       }
       obj.rel = (relationshipName) => {
         if (getRelationshipConfig(relationships[relationshipName]).isToMany) {
-          return listRelationship(this.store, relationships[relationshipName])()
+          return listRelationship(this.store, relationshipName, relationships[relationshipName])()
         } else {
-          return getRelationship(this.store, relationships[relationshipName], getRelationshipConfig(relationships[relationshipName]))()
+          return getRelationship(this.store, relationshipName, relationships[relationshipName], getRelationshipConfig(relationships[relationshipName]))()
         }
       }
     }

src/module/resource/getRelationship.js

@@ -1,26 +1,28 @@
 /**
 *
 * @param {Vuex.Store} store
+* @param {String} relationshipModuleName
 * @param {Object} relatedObject
 * @param {Object} config{isToMany: boolean}
+* @param {Object} config{isToMany: boolean}
 */
-export function getRelationship (store, relatedObject, config) {
+export function getRelationship (store, relationshipModuleName, relatedObject, config) {
   return new Proxy(() => {}, {
     apply (target, thisArg, argArray) {
       const moduleType = relatedObject.data.type
-      const relatedModule = store.state[moduleType]
+      const relatedModule = store.state[moduleType] // This should work with 'relationshipModuleName' instead of 'moduleType'
 
       if (config.isToMany) {
         const [requestedId] = argArray
 
         try {
           return relatedModule.items[requestedId]
         } catch (e) {
-          throw new Error(`Related object ${relatedObject.data.id} not found in ${moduleType}`)
+          throw new Error(`Related object ${relatedObject.id} not found in ${moduleType}`)
         }
       }
 
-      return relatedModule.items[relatedObject.data.id]
+      return relatedModule.items[relatedObject.id]
     }
   })
 }

src/module/resource/listRelationship.js

@@ -1,12 +1,12 @@
 /**
 * @param {Vuex.Store} store
+* @param {String} relationshipModuleName
 * @param {Array} relatedObjects
 */
-export function listRelationship (store, relatedObjects) {
+export function listRelationship (store, relationshipModuleName, relatedObjects) {
   return new Proxy(() => {}, {
     apply (target, thisArg, argArray) {
-      const moduleName = relatedObjects.data[0].type
-      const relatedModule = store.state[moduleName]
+      const relatedModule = store.state[relationshipModuleName]
 
       const relatedObjectIds = relatedObjects.data.map(obj => obj.id)
 

src/module/resource/loadRelationship.js

@@ -1,9 +1,9 @@
-export function loadRelationship (store, currentObjectId, currentObjectType, relatedObject, config) {
+export function loadRelationship (store, currentObjectId, moduleName, relatedObject, config) {
   return () => {
     const relatedObjectType = (config.isToMany) ? relatedObject.data[0].type : relatedObject.data.type
 
     if (config.isToMany) {
-      return store.dispatch(`${currentObjectType}/listRelated${relatedObjectType}`, { id: currentObjectId })
+      return store.dispatch(`${moduleName}/listRelated${relatedObjectNameForAction}`, { id: currentObjectId })
     }
 
     return new Error('Failed to load relationship')