Duplicate task triggers are incorrectly reported as circular task dependencies

[mountaindude]

What version of Ctrl-Q are you using?

4.4.0

What version of Node.js are you using? Not applicable if you use the standalone version of Ctrl-Q.

What command did you use to start Ctrl-Q?

ctrl-q.exe qseow task-get ...

What operating system are you using?

Windows 11

What CPU architecture are you using?

What Qlik Sense versions are you using?

Describe the Bug

Scenario:

• TaskB has an upstream TaskA.
• TaskB has two triggers that trigger when TaskA completes successfully.
  • Both triggers are identical except their names.

Ctrl-Q will report the second of TaskB's triggers as a circular dependency:

├─ TaskA
│ ├─ TaskB
│ │ ├─ TaskC
│ │ ├─ TaskD
│ └─ ==> !!! Cyclic dependency detected from task "TaskA" to "TaskB"

Expected Behavior

Ctrl-Q should identify that TaskB has several identical triggers (except their names) and warn about this.
There should not be a warning about a circular load chain.

To Reproduce

No response

[mountaindude]

Seems this only occur if the top level task (TaskA) is scheduled.
In that case the log output is

warn: Cyclic dependency detected in task tree, from task "undefined" to "Reload task of Ctrl-Q task tree app A". Won't go deeper.

That undefined is not good, but the main problem is that it is NOT a circular task chain.

[mountaindude]

Latest update improved things, but reports a destination task of "undefined" in some occasions:

2024-12-16T08:04:16.501Z warn: Cyclic dependency detected in task tree. Won't go deeper.
2024-12-16T08:04:16.502Z warn:    From task : some-task
2024-12-16T08:04:16.502Z warn:    To task   : undefined

[mountaindude]

Currently circular task chains are detected by storing the entire task object in a set, and then checking if the set already contains a task.

Better would be to just store the task ID in the set.
Would be cleaner and provide a proper, deterministic way of detecting circular task chains.

[mountaindude]

There's a corner case bug:

If a task chain at some point branches off into two (or more) paths, one of the paths will be examined first wrt circular task chains. The tasks in that branch will be remembered by Ctrl-Q.
When then examining the second branch, Ctrl-Q does not reset the memory of already visited tasks, and incorrectly triggers a circular task chain warning.

A proper Depth-First Search (DFS) algorithm is needed.
Something like this:

Represent the Tasks:

• Use a dictionary or a class to represent each task, where each task has an identifier and a list of downstream tasks.

Initialize Data Structures:

• Create a set to keep track of visited nodes.
• Create a set to keep track of the current path in the DFS (this helps in identifying cycles).

DFS Function with Cycle Detection:

• Implement a recursive DFS function that traverses the tree.
• For each task, check if it is already part of the current path. If it is, a cycle is detected.
• Add the task to both the visited set and the current path set before exploring its downstream tasks.
• After exploring all downstream tasks, remove the task from the current path set.

Detect Cycles:

• If during the DFS traversal, you find that a task is already in the current path set, return True indicating a cycle exists.
• If the entire tree is traversed without finding any cycles, return False.