jQAssistant User Manual

<concept id="my-rules:MyConcept">
    <description>A human readable description of the concept.</description>
    <cypher><![CDATA[
        MATCH
          (m)-[]->(n)
          ...
        RETURN
          m, n
    ]]></cypher>
    <report primaryColumn="n" />
</concept>

[[my-rules:MyConcept]]
.A human readable description of the concept.
[source,cypher,role=concept,primaryReportColumn="n"]
----
    MATCH
      (m)-[]->(n)
      ...
    RETURN
      m, n
----

jqassistant.sh scan -f lib/,plugins/
jqassistant.sh scan -f java:classpath::classes/
jqassistant.sh scan -u http://host/artifact.jar
jqassistant.sh scan -u http://user:secret@host/artifact.jar
jqassistant.sh scan -u maven:repository::http://my.maven.repository

jqassistant.sh list-plugins

MATCH
  (:Type)-[:DECLARES]->(member),
  (member)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(injectType:Type)
WHERE
  (member:Field or member:Method)
  and injectType.fqn="javax.inject.Inject"
SET
  member:Cdi:InjectionPoint
RETURN
  member AS InjectionPoint

MATCH
  (:Type)-[:DECLARES]->(member),
  (member)-[:OF_TYPE|RETURNS]->(type),
  (member)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(producesType:Type)
WHERE
  (member:Field or member:Method)
  and producesType.fqn="javax.enterprise.inject.Produces"
MERGE
  (member)-[:PRODUCES]->(type)
RETURN
  member AS Producer

MATCH
  (:Type)-[:DECLARES]->(disposeMethod:Method)-[:HAS]->(parameter:Parameter),
  (parameter)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(disposesType:Type),
  (parameter)-[:OF_TYPE]->(type)
WHERE
  disposesType.fqn="javax.enterprise.inject.Disposes"
MERGE
  (parameter)-[:DISPOSES]->(type)
RETURN
  disposeMethod AS DisposeMethod

MATCH
  (qualifier:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(qualifierType:Type)
WHERE
  qualifierType.fqn = "javax.inject.Qualifier"
SET
  qualifier:Cdi:Qualifier
WITH
  qualifier
MATCH
  (qualifier)-[:DECLARES]->(attribute:Method),
  (attribute)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(nonbindingType:Type)
WHERE
  nonbindingType.fqn = "javax.enterprise.util.Nonbinding"
SET
  attribute:Cdi:Nonbinding
RETURN
  distinct qualifier AS Qualifier

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(scopeType:Type)
WHERE
  (e:Type or e:Method or e:Field)
  and scopeType.fqn="javax.enterprise.context.Dependent"
SET
  e:Cdi:Dependent
RETURN
  e AS DependentElement

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(scopeType:Type)
WHERE
  (e:Type or e:Method or e:Field)
  and scopeType.fqn="javax.enterprise.context.RequestScoped"
SET
  e:Cdi:RequestScoped
RETURN
  e AS RequestScopedElement

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(scopeType:Type)
WHERE
  (e:Type or e:Method or e:Field)
  and scopeType.fqn="javax.enterprise.context.SessionScoped"
SET
  e:Cdi:SessionScoped
RETURN
  e AS SessionScopedElement

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(scopeType:Type)
WHERE
  (e:Type or e:Method or e:Field)
  and scopeType.fqn="javax.enterprise.context.ConversationScoped"
SET
  e:Cdi:ConversationScoped
RETURN
  e AS ConversationScopedElement

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(scopeType:Type)
WHERE
  (e:Type or e:Method or e:Field)
  and scopeType.fqn="javax.enterprise.context.ApplicationScoped"
SET
  e:Cdi:ApplicationScoped
RETURN
  e AS ApplicationScopedElement

MATCH
  (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn = "javax.inject.Singleton"
SET
  t:Cdi:SingletonScoped
RETURN
  t AS cdiSingleton

MATCH
  (stereotype:Type:Annotation)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(stereotypeType:Type)
WHERE
  stereotypeType.fqn="javax.enterprise.inject.Stereotype"
SET
  stereotype:Cdi:Stereotype
RETURN
  stereotype AS Stereotype

MATCH
  (alternative:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(alternativeType:Type)
WHERE
  alternativeType.fqn="javax.enterprise.inject.Alternative"
SET
  alternative:Cdi:Alternative
RETURN
  alternative AS Alternative

MATCH
  (specializes)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(specializesType:Type)
WHERE
  (specializes:Type or specializes:Method)
  and specializesType.fqn="javax.enterprise.inject.Specializes"
SET
  specializes:Cdi:Specializes
RETURN
  specializes AS Specialization

MATCH
  (delegate:Field)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(delegateType:Type)
WHERE
  delegateType.fqn="javax.decorator.Delegate"
SET
  delegate:Cdi:Delegate
RETURN
  delegate AS Delegate

MATCH
  (decorator:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(decoratorType:Type)
WHERE
  decoratorType.fqn="javax.decorator.Decorator"
SET
  decorator:Cdi:Decorator
RETURN
  decorator AS Decorator

MATCH
  (a:Type)-[:DECLARES]->(member:Field:Cdi:InjectionPoint),
  (member)-[:OF_TYPE]->(injectType:Type)
WHERE
  injectType.fqn = "javax.enterprise.event.Event"
SET
  a:Cdi:EventProducer
RETURN
  DISTINCT a.fqn AS cdiEventProducers

MATCH
  (a:Type)-[:DECLARES]->(member:Method)-[:HAS]->(param:Parameter),
  (param)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(injectType:Type)
WHERE
  injectType.fqn = "javax.enterprise.event.Observes"
SET
  a:Cdi:EventConsumer
RETURN
  DISTINCT a.fqn AS cdiEventConsumer

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(namedType:Type)
WHERE
  namedType.fqn = "javax.inject.Named"
SET
  e:Cdi:Named
RETURN
  e AS Named

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(defaultType:Type)
WHERE
  defaultType.fqn = "javax.enterprise.inject.Default"
SET
  e:Cdi:Default
RETURN
  e AS Default

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(anyType:Type)
WHERE
  anyType.fqn = "javax.enterprise.inject.Any"
SET
  e:Cdi:Any
RETURN
  e AS Any

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(newType:Type)
WHERE
  newType.fqn = "javax.enterprise.inject.New"
SET
  e:Cdi:New
RETURN
  e AS New

MATCH
  (a:Type)-[:DECLARES]->(member:Cdi:InjectionPoint)
WHERE
  NOT member:Constructor
RETURN
  DISTINCT a.fqn AS invalidBean

MATCH
  (a:Type)-[:DECLARES]->(member:Field:Cdi:InjectionPoint)
RETURN
  DISTINCT a.fqn AS invalidBean

MATCH
  (delegate:Field)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(delegateType:Type)
WHERE
  delegateType.fqn="javax.decorator.Delegate"
SET
  delegate:Decorator:Delegate
RETURN
  delegate AS Delegate

MATCH
  (decorator:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(decoratorType:Type)
WHERE
  decoratorType.fqn="javax.decorator.Decorator"
SET
  decorator:Decorator
RETURN
  decorator AS Decorator

MATCH
  (interceptor:Type:Class)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(interceptorType:Type)
WHERE
  interceptorType.fqn = "javax.interceptor.Interceptor"
SET
  interceptor:Interceptor
RETURN
  interceptor AS Interceptor

MATCH
  (binding:Type:Annotation)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(bindingType:Type)
WHERE
  bindingType.fqn = "javax.interceptor.InterceptorBinding"
SET
  binding:Interceptor:Binding
RETURN
  binding AS InterceptorBinding

MATCH (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE a.fqn="javax.ejb.Stateless"
SET t:Ejb:Stateless
RETURN t AS StatelessEjb

MATCH (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE a.fqn="javax.ejb.Stateful"
SET t:Ejb:Stateful
RETURN t AS StatefulEjb

MATCH (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE a.fqn="javax.ejb.Singleton"
SET t:Ejb:Singleton
RETURN t AS SingletonEjb

MATCH (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE a.fqn="javax.ejb.MessageDriven"
SET t:Ejb:MessageDriven
RETURN t AS MessageDrivenBean

MATCH (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE a.fqn="javax.ejb.Local"
SET t:Ejb:Local
RETURN t AS LocalBean

MATCH (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE a.fqn="javax.ejb.Remote"
SET t:Ejb:Remote
RETURN t AS RemoteBean

MATCH (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE a.fqn="javax.ejb.Schedule"
SET m:Schedule
RETURN m AS ScheduledMethod

MATCH (c:Class)-[:DECLARES]->(m:Method:Schedule)
WHERE NOT c:Ejb
RETURN c.fqn AS invalidBean, m.name AS scheduledMethodName

<jqassistant-rules xmlns="http://schema.jqassistant.org/rule/v1.8"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://schema.jqassistant.org/rule/v1.8 https://schema.jqassistant.org/rule/jqassistant-rule-v1.8.xsd">

    <concept id="report:PackageDependencies.graphml">
        <requiresConcept refId="dependency:Package" />
        <description>Reports all package dependencies.</description>
        <cypher><![CDATA[
            MATCH
              (p1:Package)-[d:DEPENDS_ON]->(p2:Package)
            RETURN
              p1, d, p2
        ]]></cypher>
    </concept>

</jqassistant-rules>

<jqassistant-rules xmlns="http://schema.jqassistant.org/rule/v1.8"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://schema.jqassistant.org/rule/v1.8 https://schema.jqassistant.org/rule/jqassistant-rule-v1.8.xsd">

    <concept id="report:VirtualPackageDependencies.graphml">
        <description>Reports all package dependencies.</description>
        <cypher><![CDATA[
            MATCH
              (p1:Package)-[:CONTAINS]->(t1:Type),
              (p2:Package)-[:CONTAINS]->(t2:Type),
              (t1)-[:DEPENDS_ON]->(t2)
            RETURN
              p1,
              {
                role: "relationship",
                type: "DEPENDS_ON",
                startNode: p1,
                endNode: p2
              },
              p2
        ]]></cypher>
    </concept>

</jqassistant-rules>

<jqassistant-rules xmlns="http://schema.jqassistant.org/rule/v1.8"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://schema.jqassistant.org/rule/v1.8 https://schema.jqassistant.org/rule/jqassistant-rule-v1.8.xsd">

    <concept id="report:VirtualDataNode.graphml">
        <description>Aggregates data in a virtual node.</description>
        <cypher><![CDATA[
            MATCH
              (m:Method)
            RETURN
              {
                role: "node",
                properties: {totalCyclomaticComplexity : sum(m.cyclomaticComplexity)},
                labels: ["Metrics", "CyclomaticComplexity"]
              }
        ]]></cypher>
    </concept>

</jqassistant-rules>

<jqassistant-rules xmlns="http://schema.jqassistant.org/rule/v1.8"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://schema.jqassistant.org/rule/v1.8 https://schema.jqassistant.org/rule/jqassistant-rule-v1.8.xsd">

    <concept id="report:Subgraph.graphml">
        <description>Creates a Subgraph for a better overview.</description>
        <cypher><![CDATA[
            MATCH
              (t:Class)-[:DECLARES]->(m:Method)
            OPTIONAL MATCH
              (m)-[i:INVOKES]->(:Method)
            RETURN
              {
                role: "graph",
                parent: t,
                nodes: collect(m),
                relationships: collect(i)  (1)
              } as subgraph
        ]]></cypher>
    </concept>

</jqassistant-rules>

MATCH
  (:Type)-[:DECLARES]->(innerType:Type)
SET
  innerType:Inner
RETURN
  innerType AS InnerType

MATCH
  (innerType:Inner:Type)
WHERE
  innerType.name =~ ".*\\$[0-9]*"
SET
  innerType:Anonymous
RETURN
  innerType AS AnonymousInnerType

MATCH
  (type:Type)
MERGE
  (type)-[:ASSIGNABLE_FROM]->(type)
WITH
  type
MATCH
  (type)-[:IMPLEMENTS|EXTENDS*]->(superType:Type)
WITH
  type, collect(distinct superType) as superTypes
UNWIND
  superTypes as superType
MERGE
  (superType)-[:ASSIGNABLE_FROM]->(type)
RETURN type AS AssignableType, superType AS AssignableFrom

MATCH
  (type:Java:Type)-[:DECLARES]->(member:Member),
  (superType:Java:Type)-[:DECLARES]->(superMember:Member),
  path=shortestPath((type)-[:EXTENDS|IMPLEMENTS*]->(superType))
WHERE
  type <> superType
  and not exists(member.name)
  and exists(superMember.name)
  and member.signature = superMember.signature
  and superMember.visibility <> "private"
WITH
  type, member, superType, superMember, length(path) as depth
ORDER BY
  depth asc
WITH
  member, head(collect(superMember)) as inheritedMember
MERGE
  (member)-[:INHERITED_FROM]->(inheritedMember)
RETURN
  count(*) as InheritedMembers

MATCH
  (type:Type)-[:DECLARES]->(method:Method),
  (superType:Type)-[:DECLARES]->(superMethod:Method),
  path=(type)-[:EXTENDS|IMPLEMENTS*]->(superType)
WHERE
  method.signature = superMethod.signature
  and superMethod.visibility <> "private"
  and not (
    (method)-[:INHERITED_FROM]->(:Method)
    or (superMethod)-[:INHERITED_FROM]->(:Method)
  )
WITH
  type, method, superType, superMethod, length(path) as depth
ORDER BY
  depth asc
WITH
  method, head(collect(superMethod)) as overriddenMethod
MERGE
  (method)-[:OVERRIDES]->(overriddenMethod)
RETURN
  count(*) as OverriddenMethods

MATCH
  (method:Method)-[invokes:INVOKES]->(:Method)-[:INHERITED_FROM*0..1]->(invokedMethod:Method),
  (invokedMethod)<-[:OVERRIDES*0..]-(overridingMethod:Method)
WHERE NOT (                                     // exclude...
  exists(overridingMethod.abstract)             // ...abstract methods
  or (overridingMethod)-[:INHERITED_FROM]->()   // ...inherited methods
)
WITH
  method, overridingMethod, coalesce(invokes.lineNumber, -1) as lineNumber
MERGE
  (method)-[virtualInvokes:VIRTUAL_INVOKES{lineNumber:lineNumber}]->(overridingMethod)
RETURN
  count(virtualInvokes) as VirtualInvokes

MATCH
  (type:Type)-[:EXTENDS|IMPLEMENTS*]->(superType:Type),
  (dependent:Type)-[:DEPENDS_ON]->(superType)
WHERE NOT (
  superType.fqn = "java.lang.Object"
  or (dependent)-[:EXTENDS|IMPLEMENTS*]->(superType) // exclude types sharing the same super classes/interfaces
)
WITH
  dependent, collect(distinct type) as types
UNWIND
  types as type
MERGE
  (dependent)-[virtualDependsOn:VIRTUAL_DEPENDS_ON]->(type)
RETURN
  count(virtualDependsOn) AS VirtualDependsOn

MATCH
  (type:Type)-[:DECLARES]->(method:Method),
  (type)-[:DECLARES]->(otherMethod:Method)
WHERE
  method <> otherMethod
  AND method.name = otherMethod.name
  AND method.signature <> otherMethod.signature
MERGE
  (method)-[:OVERLOADS]->(otherMethod)
RETURN method AS OverloadedMethod, type AS DeclaringType

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(dt:Type)
WHERE
  dt.fqn='java.lang.Deprecated'
SET
  e:Deprecated
RETURN
  e AS DeprecatedElement

MATCH
  (exception)-[:EXTENDS*]->(t:Type)
WHERE
  t.fqn = 'java.lang.Exception'
SET
  exception:Exception
RETURN
  exception AS Exception

MATCH
  (runtimeException)-[:EXTENDS*]->(t:Type)
WHERE
  t.fqn = 'java.lang.RuntimeException'
SET
  runtimeException:RuntimeException
RETURN
  runtimeException AS RuntimeException

MATCH
  (throwable)-[:EXTENDS*]->(t:Type)
WHERE
  t.fqn = 'java.lang.Error'
SET
  throwable:Error
RETURN
  throwable AS Error

MATCH
  (throwable)-[:EXTENDS*]->(t:Type)
WHERE
  t.fqn = 'java.lang.Throwable'
SET
  throwable:Throwable
RETURN
  throwable AS Throwable

MATCH
  (:Artifact)-[:CONTAINS]->(type:Java:Type)
SET
  type.javaVersion=
  CASE type.byteCodeVersion
    WHEN 58 THEN "Java 14"
    WHEN 57 THEN "Java 13"
    WHEN 56 THEN "Java 12"
    WHEN 55 THEN "Java 11"
    WHEN 54 THEN "Java 10"
    WHEN 53 THEN "Java 9"
    WHEN 52 THEN "Java 8"
    WHEN 51 THEN "Java 7"
    WHEN 50 THEN "Java 6"
    WHEN 49 THEN "Java 5"
    WHEN 48 THEN "Java 1.4"
    WHEN 47 THEN "Java 1.3"
    WHEN 46 THEN "Java 1.2"
    WHEN 45 THEN "Java 1.1/1.0"
  END
RETURN
  count(type) as Types

MATCH
    (i:Java:Interface)-[:DECLARES]->(m:Member:Java:Method {abstract: true})
WITH
    i, count(m) AS methods
WHERE
    methods = 1
SET
    i:FunctionalInterface
RETURN
    i AS FunctionInterface

MATCH
  (type:Type:Java:Interface)-[:DECLARES]->(defaultMethod:Java:Method)
WHERE NOT
  exists(defaultMethod.abstract)
SET
  defaultMethod:Default
RETURN
  defaultMethod AS DefaultMethod, type AS Interface

MATCH
  (type:Java:Type)-[:DECLARES]->(lambda:Method)
WHERE
  exists(lambda.synthetic)
  and exists(lambda.static)
  and lambda.name starts with("lambda$")
SET
  lambda:Lambda
WITH
  type, lambda
MATCH
  (type)-[:DECLARES]->(method:Method)
WHERE
  method <> lambda
  and method.firstLineNumber <= lambda.firstLineNumber
  and method.lastLineNumber >= lambda.lastLineNumber
MERGE
  (method)-[:DECLARES_LAMBDA]->(lambda)
RETURN
  method, collect(lambda)

MATCH
  (postConstruct:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(:Type{fqn:"javax.annotation.PostConstruct"})
SET
  postConstruct:PostConstruct
RETURN
  postConstruct as PostConstruct

MATCH
  (preDestroy:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(:Type{fqn:"javax.annotation.PreDestroy"})
SET
  preDestroy:PreDestroy
RETURN
  preDestroy as PreDestroy

MATCH
  (p:Package)-[:CONTAINS]->(t:Type{sourceFileName: "package-info.java"}),
  (t)-[:ANNOTATED_BY]->(a:Annotation)
MERGE
  (p)-[:ANNOTATED_BY]->(a)
RETURN p

MATCH
  (artifact:Artifact)-[:CONTAINS]->(generatedType:Java:Type:Generated)
RETURN
  artifact as Artifact, count(generatedType) as GeneratedTypes
ORDER BY
  GeneratedTypes desc

MATCH
  (inner:Java:Type)-[requires:REQUIRES_TYPE_PARAMETER]->(requiredTypeParameter:TypeVariable),
  (outer:Java:Type)-[declares:DECLARES_TYPE_PARAMETER]->(declaredTypeParameter:TypeVariable),
  shortestPath((outer)-[:DECLARES*]->(inner))
WHERE
  outer <> inner
  and declaredTypeParameter.name = requiredTypeParameter.name
MERGE
  (requiredTypeParameter)-[declaredBy:DECLARED_BY]->(declaredTypeParameter)
RETURN
  count(declaredBy) as OuterTypeDeclarations

MATCH
  (parameterizedType:ParameterizedType)-[:OF_RAW_TYPE]->(rawType:Type),
  (parameterizedType)-[hasActualTypeArgument:HAS_ACTUAL_TYPE_ARGUMENT]->(typeArgument),
  (rawType)-[declaresTypeParameter:DECLARES_TYPE_PARAMETER]->(typeParameter)
WHERE
  hasActualTypeArgument.index = declaresTypeParameter.index
MERGE
  (typeArgument)-[:DECLARED_BY]->(typeParameter)
RETURN
  count(*) as TypeParameterDeclarations

MATCH
    (p1:Package)-[:CONTAINS]->(t1:Type)-[:DEPENDS_ON]->(t2:Type)<-[:CONTAINS]-(p2:Package)
WHERE
    p1<>p2
MERGE
    (p1)-[:DEPENDS_ON]->(p2)
RETURN
    p1 AS package, COUNT(DISTINCT p2) AS PackageDependencies

MATCH
  (a1:Artifact)-[:CONTAINS]->(:Type)-[:DEPENDS_ON]->(type:Type)
WITH
  a1,type.fqn as fqn
MATCH
  (a2:Artifact)-[:CONTAINS]->(t2:Type)
WHERE
  a1 <> a2
  and t2.fqn = fqn
MERGE
  (a1)-[d:DEPENDS_ON]->(a2)
SET
  d.used=true
RETURN
  a1 AS Artifact, COLLECT(DISTINCT a2.fqn) AS Dependencies

MATCH
    (p1:Package)-[:DEPENDS_ON]->(p2:Package),
    path=shortestPath((p2)-[:DEPENDS_ON*]->(p1))
WHERE
    p1<>p2
RETURN
    p1 as Package, nodes(path) as Cycle
ORDER BY
    Package.fqn

MATCH
    (a1:Artifact)-[:DEPENDS_ON]->(a2:Artifact),
    path=shortestPath((a2)-[:DEPENDS_ON*]->(a1))
WHERE
    a1<>a2
RETURN
    a1 as Artifact, nodes(path) as Cycle
ORDER BY
    Artifact.fqn

MATCH
  (a1:Artifact)-[:REQUIRES]->(t1:Type)
WITH
  a1, t1, t1.fqn as fqn
MATCH
  (a2:Artifact)-[:CONTAINS]->(t2:Type)
WHERE
  t2.fqn=t1.fqn
MERGE
  (t1)-[r:RESOLVES_TO]->(t2)
RETURN
  count(r) as ResolvedTypes

MATCH
  (t1:Type)-[:RESOLVES_TO]->(t2:Type),
  (t1)-[:DECLARES]->(m1),
  (t2)-[:DECLARES]->(m2)
WHERE
  (m1:Field or m1:Method)
  and m1.signature = m2.signature
MERGE
  (m1)-[r:RESOLVES_TO]->(m2)
RETURN
  count(r) as ResolvedMembers

MATCH
  (t1:Type)-[:DEPENDS_ON{resolved:true}]->(t2:Type)
RETURN
  count(*) as ResolvedDependencies

MATCH
  (t:Type)-[dependsOn:DEPENDS_ON]->(t1:Type)-[:RESOLVES_TO]->(t2:Type)
MERGE
  (t)-[dependsOn1:DEPENDS_ON]->(t2)
SET
  dependsOn1=dependsOn,
  dependsOn1.resolved=true
RETURN
  count(dependsOn1) as ResolvedDependencies

MATCH
  (t:Type)-[extends:EXTENDS]->(t1:Type)-[:RESOLVES_TO]->(t2:Type)
MERGE
  (t)-[extends1:EXTENDS]->(t2)
SET
  extends1=extends,
  extends1.resolved=true
RETURN
  count(extends1) as ResolvedSuperClass

MATCH
  (t:Type)-[implements:IMPLEMENTS]->(t1:Type)-[:RESOLVES_TO]->(t2:Type)
MERGE
  (t)-[implements1:IMPLEMENTS]->(t2)
SET
  implements1=implements,
  implements1.resolved=true
RETURN
  count(implements1) as ResolvedInterfaces

MATCH
  (f:Field)-[ofType:OF_TYPE]->(:Type)-[:RESOLVES_TO]->(t:Type)
MERGE
  (f)-[ofType1:OF_TYPE]->(t)
SET
  ofType1=ofType,
  ofType1.resolved=true
RETURN
  count(ofType1) as ResolvedFieldTypes

MATCH
  (m:Method)-[throws:THROWS]->(:Type)-[:RESOLVES_TO]->(t:Type)
MERGE
  (m)-[throws1:THROWS]->(t)
SET
  throws1=throws,
  throws1.resolved=true
RETURN
  count(throws1) as ResolvedExceptionTypes

MATCH
  (m:Method)-[returns:RETURNS]->(:Type)-[:RESOLVES_TO]->(t:Type)
MERGE
  (m)-[returns1:RETURNS]->(t)
SET
  returns1=returns,
  returns1.resolved=true
RETURN
  count(returns1) as ResolvedReturnTypes

MATCH
  (m:Parameter)-[ofType:OF_TYPE]->(:Type)-[:RESOLVES_TO]->(t:Type)
MERGE
  (m)-[ofType1:OF_TYPE]->(t)
SET
  ofType1=ofType,
  ofType1.resolved=true
RETURN
  count(ofType1) as ResolvedParameterTypes

MATCH
  (a:Annotation)-[ofType:OF_TYPE]->(:Type)-[:RESOLVES_TO]->(t:Type)
MERGE
  (a)-[ofType1:OF_TYPE]->(t)
SET
  ofType1=ofType,
  ofType1.resolved=true
RETURN
  count(ofType1) as ResolvedAnnotationTypes

MATCH
  (b:Bound)-[ofRawType:OF_RAW_TYPE]->(:Type)-[:RESOLVES_TO]->(t:Type)
MERGE
  (b)-[ofRawType1:OF_RAW_TYPE]->(t)
SET
  ofRawType1=ofRawType,
  ofRawType1.resolved=true
RETURN
  count(ofRawType1) as ResolvedRawTypes

MATCH
  (v:Value)-[is:IS]->(e)-[:RESOLVES_TO]->(e2)
MERGE
  (v)-[is1:IS]->(e2)
SET
  is1=is,
  is1.resolved=true
RETURN
  count(is1) as ResolvedValueTypes

MATCH
  (m:Method)-[reads:READS]->(f1:Field)-[:RESOLVES_TO]->(f2:Field)
MERGE
  (m)-[reads1:READS {relationId: id(reads)}]->(f2)
SET
  reads1=reads,
  reads1.resolved=true
REMOVE
  reads1.relationId
RETURN
  count(reads1) as ResolvedReads

MATCH
  (m:Method)-[writes:WRITES]->(f1:Field)-[:RESOLVES_TO]->(f2:Field)
MERGE
  (m)-[writes1:WRITES {relationId: id(writes)}]->(f2)
SET
  writes1=writes,
  writes1.resolved=true
REMOVE
  writes1.relationId
RETURN
  count(writes1) as ResolvedWrites

MATCH
  (m:Method)-[invokes:INVOKES]->(m1:Method)-[:RESOLVES_TO]->(m2:Method)
MERGE
  (m)-[invokes1:INVOKES {relationId : id(invokes)}]->(m2)
SET
  invokes1=invokes,
  invokes1.resolved=true
REMOVE
  invokes1.relationId
RETURN
  count(invokes1) as ResolvedInvocations

MATCH
  ()-[r:RESOLVES_TO]->()
RETURN
  count(r) as ResolvedElements

MATCH
  (a:Type)
WHERE
  a.fqn IN ["javax.ws.rs.GET", "javax.ws.rs.POST", "javax.ws.rs.PUT", "javax.ws.rs.DELETE", "javax.ws.rs.HEAD", "javax.ws.rs.OPTIONS"]
SET
  a:JaxRS:RequestMethodDesignator
RETURN
  a AS RequestMethodDesignator

MATCH
  (t:Type)-[:DECLARES]->(m:Method)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:Type)
WHERE
  (a:JaxRS:RequestMethodDesignator OR a.fqn="javax.ws.rs.Path")
AND
  (t:Class OR t:Interface)
SET
  t:JaxRS:Resource
RETURN
  DISTINCT t AS RestResource

MATCH
  (t:Type)-[:DECLARES]->(m:Method)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn = "javax.ws.rs.Path"
AND
  (t:Class OR t:Interface)
AND
  NOT (m)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(:JaxRS:RequestMethodDesignator)
AND
  (m)-[:HAS]->(:Parameter)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(:Type)
SET
  m:JaxRS:SubResourceLocator
RETURN
  DISTINCT m AS RestSubResourceLocator

MATCH
  (c:JaxRS:Resource)-[:DECLARES]->(m:Method)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:JaxRS:RequestMethodDesignator)
SET
  m:JaxRS:ResourceMethod
RETURN
  m AS ResourceMethod

MATCH
  (m:JaxRS:ResourceMethod)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:JaxRS:RequestMethodDesignator)
WHERE
  a.fqn = "javax.ws.rs.GET"
SET
  m:GetResourceMethod
RETURN
  m AS GetMethod

MATCH
  (m:JaxRS:ResourceMethod)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:JaxRS:RequestMethodDesignator)
WHERE
  a.fqn = "javax.ws.rs.PUT"
SET
  m:PutResourceMethod
RETURN
  m AS PutMethod

MATCH
  (m:JaxRS:ResourceMethod)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:JaxRS:RequestMethodDesignator)
WHERE
  a.fqn = "javax.ws.rs.POST"
SET
  m:PostResourceMethod
RETURN
  m AS PostMethod

MATCH
  (m:JaxRS:ResourceMethod)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:JaxRS:RequestMethodDesignator)
WHERE
  a.fqn = "javax.ws.rs.DELETE"
SET
  m:DeleteResourceMethod
RETURN
  m AS DeleteMethod

MATCH
  (m:JaxRS:ResourceMethod)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:JaxRS:RequestMethodDesignator)
WHERE
  a.fqn = "javax.ws.rs.HEAD"
SET
  m:HeadResourceMethod
RETURN
  m AS HeadMethod

MATCH
  (m:JaxRS:ResourceMethod)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:JaxRS:RequestMethodDesignator)
WHERE
  a.fqn = "javax.ws.rs.OPTIONS"
SET
  m:OptionsResourceMethod
RETURN
  m AS OptionsMethod

MATCH
  (c:Type:Class)-[:IMPLEMENTS]->(a:Type)
WHERE
  a.fqn IN ["javax.ws.rs.ext.MessageBodyReader", "javax.ws.rs.ext.MessageBodyWriter"]
SET
  c:JaxRS:EntityProvider
RETURN
  DISTINCT c AS EntityProvider

MATCH
  (c:Type:Class)-[:IMPLEMENTS]->(a:Type)
WHERE
  a.fqn = "javax.ws.rs.ext.ContextResolver"
SET
  c:JaxRS:ContextProvider
RETURN
  DISTINCT c AS ContextProvider

MATCH
  (c:Type:Class)-[:IMPLEMENTS]->(a:Type)
WHERE
  a.fqn = "javax.ws.rs.ext.ExceptionMapper"
SET
  c:JaxRS:ExceptionMappingProvider
RETURN
  DISTINCT c AS ExceptionMappingProvider

MATCH
  (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="javax.persistence.Entity"
SET
  t:Jpa:Entity
RETURN
  t AS JpaEntity

MATCH
  (t:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="javax.persistence.Embeddable"
SET
  t:Jpa:Embeddable
RETURN
  t AS JpaEmbeddable

MATCH
  (t:Type)-[:DECLARES]->(member),
  (member)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  (member:Field or member:Method)
  and a.fqn="javax.persistence.Embedded"
SET
  member:Jpa:Embedded
RETURN
  member AS JpaEmbedded

MATCH
  (t:Type)-[:DECLARES]->(member),
  (member)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  (member:Field or member:Method)
  and a.fqn="javax.persistence.EmbeddedId"
SET
  member:Jpa:EmbeddedId
RETURN
  member AS EmbeddedId

MATCH
  (entity:Jpa:Entity),
  (entity)-[:ANNOTATED_BY]->(namedQueries:Annotation)-[:OF_TYPE]-(:Type{fqn:'javax.persistence.NamedQueries'}),
  (namedQueries)-[:HAS]->(:Value:Array)-[:CONTAINS]->(namedQuery),
  (namedQuery)-[:OF_TYPE]->(:Type{fqn:'javax.persistence.NamedQuery'}),
  (namedQuery)-[:HAS]->(nameAttribute:Value{name:'name'}),
  (namedQuery)-[:HAS]->(queryAttribute:Value{name:'query'})
MERGE
  (entity)-[:DEFINES]->(n:Jpa:NamedQuery {name:nameAttribute.value})
SET
  n.query=queryAttribute.value
RETURN
  entity as Entity, n.name as Name, n.query as Query
UNION ALL
MATCH
  (entity)-[:ANNOTATED_BY]->(namedQuery:Annotation),
  (namedQuery)-[:OF_TYPE]->(:Type{fqn:'javax.persistence.NamedQuery'}),
  (namedQuery)-[:HAS]->(nameAttribute:Value{name:'name'}),
  (namedQuery)-[:HAS]->(queryAttribute:Value{name:'query'})
MERGE
  (entity)-[:DEFINES]->(n:Jpa:NamedQuery {name:nameAttribute.value})
SET
  n.query=queryAttribute.value
RETURN
  entity as Entity, n.name as Name, n.query as Query

MATCH
  (pu:PersistenceUnit)
WHERE
  not exists(pu.validationMode)
  OR NOT (
    pu.validationMode='CALLBACK'
    OR pu.validationMode='NONE'
  )
RETURN
  pu AS PersistenceUnit