readyWhen not honored on continuous target

[techfg]

Current Behavior

When a target relies on a continuous target that is configured with readyWhen, the readyWhen configuration of the continuous target is not honored and the specified target executes immediately, before the continuous target has met the readyWhen conditions.

Use Case: Test suite relies on dev target but must wait for dev to be ready before it starts to execute tests. With dev configured as continuous, there needs to be a way to ensure that tests don't start until dev is fully ready. The only way that it appears nx supports this configuration is via readyWhen but readyWhen is ignored when continuous is configured.

Expected Behavior

readyWhen should be honored for continuous targets and targets that depend on the continuous target not started until readyWhen conditions are met.

GitHub Repo

https://github.com/techfg/nx-21-continuous-tasks-repros

Steps to Reproduce

1. git clone https://github.com/techfg/nx-21-continuous-tasks-repros.git
2. npx nx run waitForDevReadyWhenContinuous

Actual Behavior: waitForDevReadyWhenContinuous starts immediately and does not wait until devReadyWhenContinuous has met its readyWhen conditions

Nx Report

Node           : 22.16.0
OS             : linux-x64
Native Target  : x86_64-linux
npm            : 10.9.2

nx             : 21.1.3
@nx/js         : 21.1.3
@nx/workspace  : 21.1.3
@nx/devkit     : 21.1.3
typescript     : 5.7.3
---------------------------------------
Registered Plugins:
@nx/js/typescript
---------------------------------------
Cache Usage: 0.00 B / 100.69 GB

Failure Logs

Package Manager Version

npm 10.9.2

Operating System

• macOS
• Linux
• Windows
• Other (Please specify)

Additional Information

• The doc description for readyWhen is somewhat contradictory to the name of the option so possibly I am misunderstanding the intent/purpose of this option. The docs use the terminology done, but the name of the option is readyWhen so it's not 100% clear if this is supposed to indicate when a task is "done" or "ready". Given the name, the assumption is that when it's "ready" which would align with the use case described above as it relates to continuous tasks.
• Running npx nx run waitForDevReadyWhen waits for devReadyWhen as expected since devReadyWhen is not configured as continuous
• Related nx:run-commands does not honor readyWhen when only one command configured #31495
• Workaround is to have a separate non-continuous target waitForDev that dependsOn the continuous target dev and "polls" (e.g. checks a /health route for 200) and have the test target dependsOn waitForDev instead of dev. While this works as needed, it's all unnecessary configuration and readyWhen should be honored regardless of continuous configuration value (or another stock method to support this incredibly likely common use case added).

[RoeeIfergan]

same problem here with the @nx/vite executor.
I'm using the @nx/vite:build executor for building a ts package (continuous target). Other packages are dependent on this one's build.
Due to this bug, dependent targets start alonside the vite build causing their builds to fail.

Vite executor build target config:

"build:watch": {
        "continuous": true,
        "executor": "@nx/vite:build",
        "options": {
          "outputPath": "libs/types/dist",
          "entryFile": "src/index.ts",
          "tsConfig": "libs/types/tsconfig.lib.json",
          "configFile": "libs/types/vite.config.ts",
          "watch": true,
          "readyWhen": [
            "built in"
          ]
        }
      },

dependent target:

"build:watch": {
        "continuous": true,
        "executor": "@nx/vite:build",
        "options": {
          "outputPath": "libs/schemas/dist",
          "entryFile": "src/index.ts",
          "tsConfig": "libs/schemas/tsconfig.lib.json",
          "configFile": "libs/schemas/vite.config.ts",
          "watch": true
        },
        "dependsOn": [
          {
            "projects": [
              "@pro4/types"
            ],
            "target": "build:watch"
          }
        ]
      }

I have found a (slow) solution for this:

"build:watch": {
        "continuous": true,
        "executor": "@nx/vite:build",
        "options": {
          "outputPath": "libs/types/dist",
          "entryFile": "src/index.ts",
          "tsConfig": "libs/types/tsconfig.lib.json",
          "configFile": "libs/types/vite.config.ts",
          "watch": true
        }
      },
      "watch:ready": {
        "executor": "nx:run-commands",
        "options": {
          "commands": [
            "sleep 1 && echo 'FINISHED'",
            "nx run @pro4/types:build:watch"
          ],
          "readyWhen": [
            "built in",
            "FINISHED"
          ],
          "parallel": true
        }
      }

Would love for this bug being fixed!

[JesseZomer]

Any updates on this?

[AgentEnder]

Hey, sorry this has sat for a long time. readyWhen is an option for run-commands, that specifies when the next command in the commands array should be ready to start. It is not used by Nx's task runner.

Nx's current design philosophy for continuous tasks does not provide a way for a task to mark itself as ready, with the idea that tasks that depend on a continuous task should have some way to check when that task is ready and have some builtin waiting / retries around that. This is similar to how playwright handles web servers. They start the underlying server immediately, and will start checking if the url you provided is available immediately and then start the tests when that condition is met.

I'm going to close this out and transfer it to a discussion as a potential feature request, but its something we've discussed and the current thought train matches implementation.

[JesseZomer]

Thanks for the update.

That's interesting, so I'm trying to figure out how that would work in my example. We've got an angular dev server that depends on a graphql codegen watchmode continuous task. How would I even add something to check for to the angular dev server. And what would it check? There might still be generated files from the previous run.

How I've fixed it now is by doing the following:

        "watch-codegen": {
            "executor": "nx:run-commands",
            "options": {
                "commands": [
                    "echo extra command because of https://github.com/nrwl/nx/issues/31495 ",
                    "npx graphql-codegen --config libs/docent/graphql-codegen/codegen.ts --watch"
                ],
                "readyWhen": "GraphQL code generation complete!"
            },

so marking watch-codegen as no longer continuous even though it is, and using an command array to make readyWhen work. It works, but does feel a bit hacky