Neo4j query to filter out paths with specific relationship property using apoc.path.expandConfig

Using the uniqueness setting of NODE_GLOBAL in apoc.path.expandConfig means it will return at most one path for a given exits node. If you put a filter after the call, it may remove paths to exits nodes even though there exist valid paths to those nodes.

To illustrate, take this example:

The following is an approximation of your query for this graph, minus a filter:

WITH COLLECT { MATCH (t:SubObject) RETURN t } AS exits,
     COLLECT { MATCH (i:Object) RETURN i } AS candidates
MATCH (source:A)
CALL apoc.path.expandConfig(source, {
    labelFilter: "Object|SubObject",
    terminatorNodes: exits,
    whitelistNodes: candidates,
    uniqueness: "NODE_GLOBAL",
    bfs: false
}) YIELD path
RETURN path

Result:

╒═══════════════════════════════════════════════════════════════════════════╕
│path                                                                       │
╞═══════════════════════════════════════════════════════════════════════════╡
│(:A)-[:R {NotValid: false}]->(:Object)-[:R {NotValid: false}]->(:SubObject)│
├───────────────────────────────────────────────────────────────────────────┤
│(:A)-[:R {NotValid: false}]->(:Object)-[:R {NotValid: true}]->(:SubObject) │
└───────────────────────────────────────────────────────────────────────────┘

But if we add this filter between the apoc call and RETURN:

 WITH path WHERE ALL(r IN relationships(path) WHERE NOT r.NotValid)

We lose one of the paths, even though we can see from the graph that a valid path exists:

╒═══════════════════════════════════════════════════════════════════════════╕
│path                                                                       │
╞═══════════════════════════════════════════════════════════════════════════╡
│(:A)-[:R {NotValid: false}]->(:Object)-[:R {NotValid: false}]->(:SubObject)│
└───────────────────────────────────────────────────────────────────────────┘

Changing the bfs setting will not avoid the situation (and in my example, you will see it returns no paths with the filter).

It is better to use something like SHORTEST, which ensures that you get at least one path to each exits node, if a path exists:

MATCH path = ANY (source)
  ( (m WHERE NOT m IN exits)-[r:$(typesFilter) WHERE NOT r.NotValid]->
    (n:SubObject|Object WHERE n IN candidates + exits) )+ (e WHERE e IN exits)
RETURN path

SHORTEST was introduced in 5.21 (see the docs). The query also uses dynamic labels, introduced in 5.26 (see this blog).

This query may do what you want:

WITH source, candidates, exits, typesFilter
// Use APOC path expansion
CALL apoc.path.expandConfig(source, {
    labelFilter: '+Object|SubObject',
    relationshipFilter: typesFilter,
    terminatorNodes: exits,
    whitelistNodes: candidates,
    bfs: FALSE,
    uniqueness: "NODE_GLOBAL"
}) YIELD path
WHERE ALL(r IN RELATIONSHIPS(path) WHERE r.NotValid IS NULL)
RETURN relationships(path) AS validRelationships, nodes(path)

It inserts a WHERE clause to filter for the desired the paths, simplifies the calculation of validRelationships (which you may want to rename as just relationships, since after filtering all relationships would be valid), and also eliminates the unnecessary WITH clause.