elysian-breeze

what something costs to produce != worth

You can just have `Request` as a parameter and do those edge cases yourself. Or write your own Extractor which would handle that pretty easily.

I'm not sure of your use case where clients can send any format they want and the HTTP server is supposed to know and handle any format automatically (form, json, querystring, etc), but seems more like a legacy edge case than something you would do building a server from scratch.

Something like this (completely untested) but pretty straight forward to handle your usecase.

    #[derive(Debug, Clone, Copy, Default)]
    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
    pub struct FormOrJson<T>(pub T);
    
    #[async_trait]
    impl<T, S, B> FromRequest<S, B> for FormOrJson<T>
    where
        T: DeserializeOwned,
        B: HttpBody + Send + 'static,
        B::Data: Send,
        B::Error: Into<BoxError>,
        S: Send + Sync,
    {
        type Rejection = InvalidFormOrJson;
    
        async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
            if json_content_type(req.headers()) {
                let bytes = Bytes::from_request(req, state).await?;
                let deserializer = &mut serde_json::Deserializer::from_slice(&bytes);
    
                let value = match serde_path_to_error::deserialize(deserializer) {
                    Ok(value) => value,
                    Err(err) => {
                        let rejection = match err.inner().classify() {
                            serde_json::error::Category::Data => JsonDataError::from_err(err).into(),
                            serde_json::error::Category::Syntax | serde_json::error::Category::Eof => {
                                JsonSyntaxError::from_err(err).into()
                            }
                            serde_json::error::Category::Io => {
                                if cfg!(debug_assertions) {
                                    // we don't use `serde_json::from_reader` and instead always buffer
                                    // bodies first, so we shouldn't encounter any IO errors
                                    unreachable!()
                                } else {
                                    JsonSyntaxError::from_err(err).into()
                                }
                            }
                        };
                        return Err(rejection);
                    }
                };
    
                Ok(FormOrJson(value))
            } else if has_content_type(req, &mime::APPLICATION_WWW_FORM_URLENCODED) {
                let bytes = Bytes::from_request(req).await?;
                let value = serde_urlencoded::from_bytes(&bytes)
                    .map_err(FailedToDeserializeQueryString::__private_new::<(), _>)?;
    
                Ok(FormOrJson(value))
            } else {
                Err(InvalidFormOrJson.into())
            }
        }
    }

> morally, logically, legally and practically ridiculous.

Well i mean thats your opinion not the facts. There is a whole web of regulations when dealing with those countries and if they are allowed to buy from you.

There are even more laws around money movement and debt and financing.

Just declaring "it shouldnt be that way. it is unfair" doesn't change the laws.

Defi doesn't solve this at all. It is currently illegal for me and a lot of the world to buy software from Iran and Russia. Using blockchain to circumvent the law is the only use case people can scrape together.

It doesn't matter if blockchain allows you to break the law. You are still breaking the law and punishments exists outside of the chain.

Blockchain enthusiasts get confused between "a solution" and a "better solution". A car with an airplane propeller engine is technically a solution that solves a use case of getting a person from point a to point b, but is it the best solution when compared to current cars? Right now the crypto industry is slapping all sorts of stuff on and then just because their car makes it down the street, suddenly they think somebody in africa who never had a car before will want it.

The use case you describe has been beaten over and over in crypto over the past 5-7 years. DRM. Its old news. But no major company wants anything to do with it. Its a social problem not a technical one.

Blockchain is an engineers wet dream. Infinite solutions that make theoretical sense and the math works, but lack any way to solve the current problems better.

I found docker to be pleasant to work with for support services (if your app needs postgres, redis, mail service, pdf converter, object storage, etc) in development and you need an easy command (docker-compose down; docker-compose up) to tell designers and product people to easily reset their environment to a sane state.

It is NOT great for having a live-reloading dev webservice running. People seem to swing for an all in one solution, but consideration is needed about what services you want in docker or not. Docker is great to have preconfigured database environments that are easy to tear down and start from scratch and works across multiple platforms. Docker is bad for local dev server.