refactor(relationships): improve argument names

Author: digitalsadhu

lib/utilities/relationship-utils.js

@@ -91,84 +91,84 @@ function shouldIncludeRelationships (method) {
 }
 
 function updateHasMany (
-  leftPrimaryKey,
-  leftId,
+  leftPKName,
+  leftPKValue,
   RightModel,
-  rightForeignKey,
-  rightIds
+  rightFKName,
+  rightFKValues
 ) {
-  return RightModel.updateAll({ [leftPrimaryKey]: { inq: rightIds } }, {
-    [rightForeignKey]: leftId
+  return RightModel.updateAll({ [leftPKName]: { inq: rightFKValues } }, {
+    [rightFKName]: leftPKValue
   })
-    .then(() => RightModel.find({ where: { [rightForeignKey]: leftId } }))
+    .then(() => RightModel.find({ where: { [rightFKName]: leftPKValue } }))
     .then(models => {
-      const idsToUnset = _.difference(_.map(models, 'id'), rightIds)
+      const idsToUnset = _.difference(_.map(models, 'id'), rightFKValues)
       return RightModel.updateAll({ id: { inq: idsToUnset } }, {
-        [rightForeignKey]: null
+        [rightFKName]: null
       })
     })
 }
 
 function updateHasOne (
-  rightPrimaryKey,
-  leftId,
+  rightPKName,
+  leftPKValue,
   RightModel,
-  rightForeignKey,
-  rightId
+  rightFKName,
+  rightPKId
 ) {
-  return RightModel.updateAll({ [rightForeignKey]: leftId }, {
-    [rightForeignKey]: null
+  return RightModel.updateAll({ [rightFKName]: leftPKValue }, {
+    [rightFKName]: null
   })
     .then(() => {
-      if (rightId) {
-        return RightModel.updateAll({ [rightPrimaryKey]: rightId }, {
-          [rightForeignKey]: leftId
+      if (rightPKId) {
+        return RightModel.updateAll({ [rightPKName]: rightPKId }, {
+          [rightFKName]: leftPKValue
         })
       }
     })
 }
 
 function updateBelongsTo (
   LeftModel,
-  leftPrimaryKey,
-  leftId,
-  leftForeignKey,
-  rightId
+  leftPKName,
+  leftPKValue,
+  leftFKName,
+  rightPKId
 ) {
-  if (rightId === null) {
-    return LeftModel.updateAll({ [leftPrimaryKey]: leftId }, {
-      [leftForeignKey]: null
+  if (rightPKId === null) {
+    return LeftModel.updateAll({ [leftPKName]: leftPKValue }, {
+      [leftFKName]: null
     })
   }
-  return LeftModel.updateAll({ [leftPrimaryKey]: leftId }, {
-    [leftForeignKey]: rightId
+  return LeftModel.updateAll({ [leftPKName]: leftPKValue }, {
+    [leftFKName]: rightPKId
   })
 }
 
 function updateHasManyThrough (
-  leftPrimaryKey,
-  leftId,
+  leftPKName,
+  leftPKValue,
   PivotModel,
-  leftForeignKey,
-  rightForeignKey,
-  rightPrimaryKey,
-  rightIds
+  leftFKName,
+  rightFKName,
+  rightPKName,
+  rightFKValues
 ) {
-  return PivotModel.find({ where: { [leftForeignKey]: Number(leftId) } })
+  return PivotModel.find({ where: { [leftFKName]: Number(leftPKValue) } })
     .then(models => {
-      const existingIds = models.map(model => Number(model[rightForeignKey]))
-      const newIds = rightIds.map(id => Number(id))
+      const existingIds = models.map(model => Number(model[rightFKName]))
+      const newIds = rightFKValues.map(id => Number(id))
       const idsToDelete = _.difference(existingIds, newIds)
       return PivotModel.destroyAll({
-        [leftForeignKey]: Number(leftId),
-        [rightForeignKey]: { inq: idsToDelete }
+        [leftFKName]: Number(leftPKValue),
+        [rightFKName]: { inq: idsToDelete }
       })
         .then(() => {
           const idsToAdd = _.difference(newIds, existingIds)
           return PivotModel.create(
             idsToAdd.map(id => ({
-              [leftForeignKey]: Number(leftId),
-              [rightForeignKey]: id
+              [leftFKName]: Number(leftPKValue),
+              [rightFKName]: id
             }))
           )
         })
@@ -192,37 +192,37 @@ function linkRelatedModels (relationName, from, to) {
   const strategy = detectUpdateStrategy(LeftModel, relationName)
 
   if (strategy === RELATION_TYPES.HAS_MANY_THROUGH) {
-    const leftPrimaryKey = utils.primaryKeyForModel(LeftModel)
-    const rightPrimaryKey = utils.primaryKeyForModel(RightModel)
+    const leftPKName = utils.primaryKeyForModel(LeftModel)
+    const rightPKName = utils.primaryKeyForModel(RightModel)
     const PivotModel = relationDefn.modelThrough
-    const leftForeignKey = relationDefn.keyTo
-    const rightForeignKey = relationDefn.keyThrough
+    const leftFKName = relationDefn.keyTo
+    const rightFKName = relationDefn.keyThrough
     return updateHasManyThrough(
-      leftPrimaryKey,
+      leftPKName,
       id,
       PivotModel,
-      leftForeignKey,
-      rightForeignKey,
-      rightPrimaryKey,
+      leftFKName,
+      rightFKName,
+      rightPKName,
       data
     )
   }
 
   if (strategy === RELATION_TYPES.HAS_MANY) {
-    const leftPrimaryKey = utils.primaryKeyForModel(LeftModel)
-    const rightForeignKey = relationDefn.keyTo
-    return updateHasMany(leftPrimaryKey, id, RightModel, rightForeignKey, data)
+    const leftPKName = utils.primaryKeyForModel(LeftModel)
+    const rightFKName = relationDefn.keyTo
+    return updateHasMany(leftPKName, id, RightModel, rightFKName, data)
   }
 
   if (strategy === RELATION_TYPES.HAS_ONE) {
-    const rightPrimaryKey = utils.primaryKeyForModel(RightModel)
-    const rightForeignKey = relationDefn.keyTo
-    return updateHasOne(rightPrimaryKey, id, RightModel, rightForeignKey, data)
+    const rightPKName = utils.primaryKeyForModel(RightModel)
+    const rightFKName = relationDefn.keyTo
+    return updateHasOne(rightPKName, id, RightModel, rightFKName, data)
   }
 
   if (strategy === RELATION_TYPES.BELONGS_TO) {
-    const leftPrimaryKey = utils.primaryKeyForModel(LeftModel)
-    const leftForeignKey = relationDefn.keyFrom
-    return updateBelongsTo(LeftModel, leftPrimaryKey, id, leftForeignKey, data)
+    const leftPKName = utils.primaryKeyForModel(LeftModel)
+    const leftFKName = relationDefn.keyFrom
+    return updateBelongsTo(LeftModel, leftPKName, id, leftFKName, data)
   }
 }