Unexpected Change in res.is_completed() Behavior in Crow 1.2.1.2

[MESURF88]

In upgrading to Crow version 1.2.1.2, we encountered an unexpected change in how res.is_completed() behaves during request handling.

Previously, our API logic used res.is_completed() to determine if the response had already been finalized. This allowed us to short-circuit execution paths and avoid duplicate response handling in specific routes. However, after updating to 1.2.1.2, these same endpoints began consistently returning 400 Bad Request responses in cases where we rely on res.is_completed() to decide early exit conditions.

Upon investigation, we traced the issue to a change introduced in commit #799. In this commit, response writing was made synchronous, and the completed_ flag appears to be reset (cleared) after res.end() is called. As a result, calls to res.is_completed() in our logic immediately following res.end() now return false instead of true, breaking our previous flow control.

We’ve temporarily reverted to Crow 1.2 to restore the expected behavior.

Could you clarify the intended usage and contract of res.is_completed() going forward, particularly in light of this commit?
Is the response expected to appear "incomplete" until the write fully finishes now?

Thanks in advance

example of our flow control:
`
void Authorize(const crow::request& req, crow::response& res)
{

  ...

  res = crow::response(crow::status::OK, "okay");
  res.end();
  return;
}

`

`
this->Authorize(req, res);

      if (res.is_completed()) return;

      res = crow::response(crow::status::BAD_REQUEST);
      res.end();
      return;

`

[gittiver]

Actually API doc says:
bool is_completed () const noexcept
Check if the response has completed (whether [response.end()]

I would assume that is_completed will be set when response is written. But to be honest I am not shure if this is implemented.
The change to synchronous write was done due to a bug, so maybe this was not taken into account.

[MESURF88]

Looking at the source, the synchronous write calls res.clear() which sets completed_ to false. Previously the async write would defer this to later res.clear() command to later:

asio::async_write(
              adaptor_.socket(), buffers_,
              [self](const error_code& ec, std::size_t /*bytes_transferred*/) {
                  self->res.clear();
                  self->res_body_copy_.clear();                  
                  if (!self->continue_requested)
                  {
                      self->parser_.clear();
                  }
                  else
                  {
                      self->continue_requested = false;
                  }
                  
                  if (!ec)
                  {
                      if (self->close_connection_)
                      {
                          self->adaptor_.shutdown_write();
                          self->adaptor_.close();
                          CROW_LOG_DEBUG << self << " from write(1)";
                      }
                  }
                  else
                  {
                      CROW_LOG_DEBUG << self << " from write(2)";
                  }
              });

I'm not entirely sure how the mechanism for setting completed_ works or if its intended use is how we have used it