Add fine grained DEPENDS_ON relationship weights for Typescript

Author: JohT

cypher/Package_Relationship_Weights/Add_weight_property_for_Low_Coupling_Dependencies_to_Typescript_Model_DEPENDS_ON_Relationships.cypher

@@ -0,0 +1,96 @@
+// Add weight property for low coupling dependencies to Typescript module DEPENDS_ON relationships
+
+ MATCH (source:TS:Module)-[moduleDependency:DEPENDS_ON]->(target:ExternalModule)
+// Get the top level dependency between a Typescript module and the external modules it uses
+  WITH source
+      ,target
+      ,moduleDependency
+      ,count(DISTINCT target)            AS externalModuleCount
+      ,sum(moduleDependency.cardinality) AS externalModuleCardinalities
+OPTIONAL MATCH (source)-[rd:DEPENDS_ON]->(declaration:ExternalDeclaration)<-[:EXPORTS]-(target)
+// Get optional external (e.g. type) declarations that the external module (target) provides and the source module uses
+  WITH source
+      ,target
+      ,moduleDependency
+      ,externalModuleCount
+      ,externalModuleCardinalities
+      ,count(DISTINCT declaration) AS declarationCount
+      ,sum(rd.cardinality)         AS declarationCardinalities
+      ,collect(DISTINCT declaration.globalFqn)[0..4] AS declarationExamples 
+OPTIONAL MATCH (source)-[:DECLARES]->(abstraction:TypeAlias|Interface)-[ra:DEPENDS_ON]->(target)
+// Get optional low coupling elements (TypeAlias, Interface) that the source module contains and defines (low level) that depend on the external module (target)
+  WITH source
+      ,target
+      ,moduleDependency
+      ,externalModuleCount
+      ,externalModuleCardinalities
+      ,declarationCount
+      ,declarationCardinalities
+      ,declarationExamples
+      ,count(DISTINCT abstraction) AS abstractionCount
+      ,sum(ra.cardinality)         AS abstractionCardinalities
+      ,collect(DISTINCT abstraction.globalFqn)[0..4] AS abstractionExamples 
+OPTIONAL MATCH (source)-[:DECLARES]->(implementation:!TypeAlias&!Interface)-[ri:DEPENDS_ON]->(target)
+// Get optional higher coupling elements (Class, Function) that the source module contains and defines (low level) that depend on the external module (target)
+  WITH source
+      ,target
+      ,moduleDependency
+      ,externalModuleCount
+      ,externalModuleCardinalities
+      ,declarationCount
+      ,declarationCardinalities
+      ,declarationExamples
+      ,abstractionCount
+      ,abstractionCardinalities
+      ,abstractionExamples 
+      ,count(DISTINCT implementation) AS implementationCount
+      ,sum(ri.cardinality)            AS implementationCardinalities
+      ,collect(DISTINCT implementation.globalFqn)[0..4] AS implementationExamples
+// 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.
+// - "weightLowCouplingElements" is the sum of all TypeAlias, Interface and external declaration cardinalities
+//   and corresponds to the "weightInterfaces" relationship property for Java.
+// - "weight25PercentLowCouplingElements" only takes 25% of the weight for elements that are considered as low coupling
+//   like Type Declarations and Interfaces and adds the unchanged (100%) weight of "high coupling" elements like Functions and Classes.
+   SET moduleDependency.weightDeclarations        = declarationCardinalities
+      ,moduleDependency.weightAbstractions        = abstractionCardinalities
+      ,moduleDependency.weightImplementations     = implementationCardinalities
+      ,moduleDependency.weightLowCouplingElements = declarationCardinalities + abstractionCardinalities
+      ,moduleDependency.weight25PercentLowCouplingElements = toInteger(implementationCardinalities + round((declarationCardinalities + abstractionCardinalities) * 0.25))
+      ,moduleDependency.weight10PercentLowCouplingElements = toInteger(implementationCardinalities + round((declarationCardinalities + abstractionCardinalities) * 0.10))
+// Aggregate all gathered information for each (grouped by) source module
+  WITH source
+      ,source.globalFqn                 AS sourceGlobalName
+      ,source.localFqn                  AS sourceLocalName
+      ,sum(externalModuleCount)         AS externalModuleCount
+      ,sum(declarationCount)            AS declarationCount
+      ,sum(abstractionCount)            AS abstractionCount
+      ,sum(implementationCount)         AS implementationCount
+      ,sum(externalModuleCardinalities) AS externalModuleCardinalities
+      ,sum(declarationCardinalities)    AS declarationCardinalities
+      ,sum(abstractionCardinalities)    AS abstractionCardinalities
+      ,sum(implementationCardinalities) AS implementationCardinalities
+      ,collect(DISTINCT target.globalFqn)[0..4]                 AS externalModuleExamples
+      ,apoc.coll.flatten(collect(declarationExamples))[0..4]    AS declarationExamples
+      ,apoc.coll.flatten(collect(abstractionExamples))[0..4]    AS abstractionExamples
+      ,apoc.coll.flatten(collect(implementationExamples))[0..4] AS implementationExamples
+   SET source.outgoingDependencies                 = declarationCount + abstractionCount + implementationCount
+      ,source.outgoingDependenciesWeight           = declarationCardinalities + abstractionCardinalities + implementationCardinalities
+      ,source.outgoingDependentImplementations     = implementationCount
+      ,source.outgoingDependentLowCouplingElements = declarationCount + abstractionCount 
+      ,source.outgoingDependentModules             = externalModuleCount
+RETURN sourceGlobalName
+      ,sourceLocalName
+      ,externalModuleCount
+      ,declarationCount
+      ,abstractionCount
+      ,implementationCount
+      ,externalModuleCardinalities
+      ,declarationCardinalities
+      ,abstractionCardinalities
+      ,implementationCardinalities
+      ,externalModuleExamples
+      ,declarationExamples
+      ,abstractionExamples
+      ,implementationExamples
+ORDER BY sourceGlobalName ASC