Fix missing declarationCount property on DEPENDS_ON relationships

Author: JohT

cypher/DependsOn_Relationship_Weights/Add_fine_grained_weights_for_Typescript_external_module_dependencies.cypher

@@ -2,7 +2,9 @@
 
 // Get the top level dependency between a Typescript module and the external modules it uses
  MATCH (source:TS:Module)-[moduleDependency:DEPENDS_ON]->(target:ExternalModule)
- WHERE NOT EXISTS {(target)-[:RESOLVES_TO]->(source)}
+// Exclude all targets where an ExternalModule was found that resolves to them
+// because those are covered in the fine grained weights for "ExternalModule"s.
+ WHERE NOT EXISTS { (target)-[:RESOLVES_TO]->(source) }
 OPTIONAL MATCH (source)-[resolvedModuleDependency:DEPENDS_ON]->(resolvedTarget:TS:Module)<-[:RESOLVES_TO]-(target)
   WITH source
       ,target
@@ -43,15 +45,17 @@ OPTIONAL MATCH (source)-[ra:DEPENDS_ON]->(declaration)-[:RESOLVES_TO]->(abstract
 // - "lowCouplingElement25PercentWeight" subtracts 75% of the weights for abstract types like Interfaces and Type aliases
 //   to compensate for their low coupling influence. Not included "high coupling" elements like Functions and Classes 
 //   remain in the weight as they were. The same applies for "lowCouplingElement10PercentWeight" but with in a stronger manner.
-  SET moduleDependency.declarationCount        = declarationCount
-     ,moduleDependency.abstractTypeCount       = abstractTypeCount
-     ,moduleDependency.abstractTypeCardinality = abstractTypeCardinality
-     ,moduleDependency.lowCouplingElement25PercentWeight = toInteger(moduleDependency.cardinality - round(abstractTypeCardinality * 0.75))
-     ,moduleDependency.lowCouplingElement10PercentWeight = toInteger(moduleDependency.cardinality - round(abstractTypeCardinality * 0.90))
+  SET moduleDependency.declarationCount        = coalesce(declarationCount, 0)
+     ,moduleDependency.abstractTypeCount       = coalesce(abstractTypeCount, 0)
+     ,moduleDependency.abstractTypeCardinality = coalesce(abstractTypeCardinality, 0)
+     ,moduleDependency.lowCouplingElement25PercentWeight = 
+        toInteger(moduleDependency.cardinality - round(abstractTypeCardinality * 0.75))
+     ,moduleDependency.lowCouplingElement10PercentWeight = 
+        toInteger(moduleDependency.cardinality - round(abstractTypeCardinality * 0.90))
  // Set all new properties also to a resolved (direct) dependency relationship if it exists.    
-     ,resolvedModuleDependency.declarationCount        = declarationCount
-     ,resolvedModuleDependency.abstractTypeCount       = abstractTypeCount
-     ,resolvedModuleDependency.abstractTypeCardinality = abstractTypeCardinality
+     ,resolvedModuleDependency.declarationCount        = coalesce(declarationCount, 0)
+     ,resolvedModuleDependency.abstractTypeCount       = coalesce(abstractTypeCount, 0)
+     ,resolvedModuleDependency.abstractTypeCardinality = coalesce(abstractTypeCardinality, 0)
      ,resolvedModuleDependency.lowCouplingElement25PercentWeight = toInteger(resolvedModuleDependency.cardinality - round(abstractTypeCardinality * 0.75))
      ,resolvedModuleDependency.lowCouplingElement10PercentWeight = toInteger(resolvedModuleDependency.cardinality - round(abstractTypeCardinality * 0.90))
 RETURN source.globalFqn    AS sourceName

cypher/DependsOn_Relationship_Weights/Add_fine_grained_weights_for_Typescript_internal_module_dependencies.cypher

@@ -8,23 +8,29 @@
   WITH source
       ,target
       ,moduleDependency
-OPTIONAL MATCH (source)-[elementDependency:DEPENDS_ON]->(elementType:TS)<-[:EXPORTS]-(target)
+      ,moduleDependency.cardinality AS targetModuleCardinality
+
+// Get optional external (e.g. type) declarations that the external module (target) provides and the source module uses
+OPTIONAL MATCH (source)-[elementDependency:DEPENDS_ON|EXPORTS]->(elementType:TS)<-[:EXPORTS]-(target)
   WITH source
       ,target
       ,moduleDependency
-      ,count(DISTINCT elementType.globalFqn)          AS elementTypeCount
-      ,sum(elementDependency.cardinality)             AS elementTypeCardinality
-      ,collect(DISTINCT elementType.globalFqn)[0..4]  AS elementTypeExamples
-OPTIONAL MATCH (source)-[abstractDependency:DEPENDS_ON]->(abstractType:TypeAlias|Interface)<-[:EXPORTS]-(target)
+      ,targetModuleCardinality      
+      ,coalesce(count(DISTINCT elementType.globalFqn), 0) AS elementTypeCount
+      ,sum(elementDependency.cardinality)                 AS elementTypeCardinality
+      ,collect(DISTINCT elementType.globalFqn)[0..4]      AS elementTypeExamples
+// Get optional low coupling elements (TypeAlias, Interface) that the source module contains and defines (low level) that depend on the external module (target)
+OPTIONAL MATCH (source)-[abstractDependency:DEPENDS_ON|EXPORTS]->(abstractType:TypeAlias|Interface)<-[:EXPORTS]-(target)
   WITH source
       ,target
       ,moduleDependency
+      ,targetModuleCardinality      
       ,elementTypeCount        
       ,elementTypeCardinality   
       ,elementTypeExamples     
-      ,count(DISTINCT abstractType.globalFqn)         AS abstractTypeCount
-      ,sum(abstractDependency.cardinality)            AS abstractTypeCardinality
-      ,collect(DISTINCT abstractType.globalFqn)[0..4] AS abstractTypeExamples 
+      ,coalesce(count(DISTINCT abstractType.globalFqn), 0) AS abstractTypeCount
+      ,sum(abstractDependency.cardinality)                 AS abstractTypeCardinality
+      ,collect(DISTINCT abstractType.globalFqn)[0..4]      AS abstractTypeExamples 
 // Set additional fine grained relationship properties (weights) to distinguish low and high coupling elements.
 // The "cardinality" property is similar to "weight" property for Java dependencies and comes from the jQAssistant Typescript Plugin.
 // - "abstractTypeCardinality" is the sum of all TypeAlias and Interface cardinality properties (if available)
@@ -34,21 +40,22 @@ OPTIONAL MATCH (source)-[abstractDependency:DEPENDS_ON]->(abstractType:TypeAlias
 // - "lowCouplingElement25PercentWeight" subtracts 75% of the weights for abstract types like Interfaces and Type aliases
 //   to compensate for their low coupling influence. Not included "high coupling" elements like Functions and Classes 
 //   remain in the weight as they were. The same applies for "lowCouplingElement10PercentWeight" but with in a stronger manner.
- SET moduleDependency.abstractTypeCount       = abstractTypeCount
+ SET moduleDependency.declarationCount        = elementTypeCount
+    ,moduleDependency.abstractTypeCount       = abstractTypeCount
     ,moduleDependency.abstractTypeCardinality = abstractTypeCardinality
     ,moduleDependency.lowCouplingElement25PercentWeight = 
         toInteger(elementTypeCardinality - round(abstractTypeCardinality * 0.75))
     ,moduleDependency.lowCouplingElement10PercentWeight = 
         toInteger(elementTypeCardinality - round(abstractTypeCardinality * 0.90))
 RETURN source.globalFqn    AS sourceName
       ,target.globalFqn    AS targetName
-      ,abstractTypeCount
       ,elementTypeCount
-      ,moduleDependency.cardinality AS externalModuleCardinality
-      ,abstractTypeCardinality
+      ,abstractTypeCount
+      ,targetModuleCardinality      
       ,elementTypeCardinality
+      ,abstractTypeCardinality
       ,moduleDependency.lowCouplingElement25PercentWeight
       ,moduleDependency.lowCouplingElement10PercentWeight
-      ,abstractTypeExamples
       ,elementTypeExamples
+      ,abstractTypeExamples
 ORDER BY sourceName ASC