lukemathwalker / pavex Goto Github PK

thread 'main' panicked at pavexc/src/compiler/analyses/call_graph/application_state.rs:130:13:
One of the output components is not a `MatchResult` transformer: Transformer(Callable(<alloc::sync::Arc::<arc_repro::SharedDep> as core::clone::Clone>::clone(&alloc::sync::Arc<arc_repro::SharedDep>) -> alloc::sync::Arc<arc_repro::SharedDep>))

thread 'main' panicked at pavexc/src/compiler/analyses/processing_pipeline/codegen.rs:82:25:
internal error: entered unreachable code

ERROR: 
  x I don't know how to handle the type returned by `app::routes::system::health_check`.
  |
  |     ,-[app/src/routes/mod.rs:10:1]
  |  10 | pub fn handler(bp: &mut Blueprint) {
  |  11 |     bp.route(GET, "/healthz", f!(crate::routes::system::health_check));
  |     :                               ^^^^^^^^^^^^^^^^^^^|^^^^^^^^^^^^^^^^^^^
  |     :                                                  `-- The request handler was registered here
  |  12 | }
  |     `----
  |    ,-[app/src/routes/system.rs:4:1]
  |  4 | #[must_use]
  |  5 | pub const fn health_check() -> StatusCode {
  |    :                                ^^^^^|^^^^
  |    :                                     `-- The output type that I can't handle
  |  6 |     StatusCode::OK
  |    `----

pub fn tickets_bp() -> Blueprint {
    let mut bp = Blueprint::new();

    bp.request_scoped(f!(crate::tickets::TicketForCreate::extract))
        .error_handler(f!(crate::tickets::invalid_ticket));
    
    bp.request_scoped(f!(crate::ctx::Ctx::new));

    bp.pre_process(f!(super::web::mw_auth::mw_require_auth))
        .error_handler(f!(super::web::mw_auth::mw_auth_error));

    bp.route(POST, "/tickets", f!(self::tickets::post));
    bp.route(GET, "/tickets", f!(self::tickets::get));
    bp.route(DELETE, "/tickets/:id", f!(self::tickets::delete));
    bp
}

pub async fn mw_require_auth(request_cookies: RequestCookies<'_>, ctx: &mut Ctx) -> Result<Processing, AuthError> {
    [...]
    ctx.set(user_id);

    tracing::Span::current().record("auth_status", "success");
    Ok(Processing::Continue)
}

pub async fn get(mc: &ModelController, ctx: Ctx) -> Response {
    let tickets = mc.list_tickets(ctx).await;
    [...]
}

    pub async fn list_tickets(&self, _ctx: Ctx) -> Result<Vec<Ticket>, TicketError> {
        let store = self.tickets_store.lock().await;
        let tickets = store.iter().filter_map(|t| t.clone()).collect();
        Ok(tickets)
    }

    async fn pre_processing_0(
        v0: &biscotti::Processor,
        v1: &pavex::request::RequestHead,
    ) -> pavex::middleware::Processing {
        [....]
        let mut v4 = app::ctx::Ctx::new();
        let v5 = app::routes::web::mw_auth::mw_require_auth(v3, &mut v4).await;
        [....]
    }

    async fn handler(
        v0: &app::configuration::ModelController,
        // assuming missing input parameter `vX: &app::ctx::Ctx`
    ) -> pavex::response::Response {
        let v1 = app::routes::web::tickets::get(v0).await; // <--- missing argument for `vX` of type ctx: Ctx
        <pavex::response::Response as pavex::response::IntoResponse>::into_response(v1)
    }

error[E0433]: failed to resolve: use of undeclared crate or module `alloc`
  --> arc_repro_server_sdk/src/lib.rs:97:13
   |
97 |         v1: alloc::sync::Arc<arc_repro::ExampleDependency>,
   |             ^^^^^ use of undeclared crate or module `alloc`
   |
   = help: add `extern crate alloc` to use the `alloc` crate
help: consider importing one of these items
   |
95 +     use crate::alloc::sync;
   |
95 +     use std::sync;
   |
help: if you import `sync`, refer to it directly
   |
97 -         v1: alloc::sync::Arc<arc_repro::ExampleDependency>,
97 +         v1: sync::Arc<arc_repro::ExampleDependency>,
   |

error[E0433]: failed to resolve: use of undeclared crate or module `alloc`
   --> arc_repro_server_sdk/src/lib.rs:109:13
    |
109 |         v0: alloc::sync::Arc<arc_repro::ExampleDependency>,
    |             ^^^^^ use of undeclared crate or module `alloc`
    |
    = help: add `extern crate alloc` to use the `alloc` crate
help: consider importing one of these items
    |
95  +     use crate::alloc::sync;
    |
95  +     use std::sync;
    |
help: if you import `sync`, refer to it directly
    |
109 -         v0: alloc::sync::Arc<arc_repro::ExampleDependency>,
109 +         v0: sync::Arc<arc_repro::ExampleDependency>,
    |

error[E0433]: failed to resolve: use of undeclared crate or module `alloc`
   --> arc_repro_server_sdk/src/lib.rs:118:14
    |
118 |         s_0: alloc::sync::Arc<arc_repro::ExampleDependency>,
    |              ^^^^^ use of undeclared crate or module `alloc`
    |
    = help: add `extern crate alloc` to use the `alloc` crate
help: consider importing one of these items
    |
95  +     use crate::alloc::sync;
    |
95  +     use std::sync;
    |
help: if you import `sync`, refer to it directly
    |
118 -         s_0: alloc::sync::Arc<arc_repro::ExampleDependency>,
118 +         s_0: sync::Arc<arc_repro::ExampleDependency>,
    |

error[E0433]: failed to resolve: use of undeclared crate or module `alloc`
   --> arc_repro_server_sdk/src/lib.rs:119:18
    |
119 |         next: fn(alloc::sync::Arc<arc_repro::ExampleDependency>) -> T,
    |                  ^^^^^ use of undeclared crate or module `alloc`
    |
    = help: add `extern crate alloc` to use the `alloc` crate
help: consider importing one of these items
    |
95  +     use crate::alloc::sync;
    |
95  +     use std::sync;
    |
help: if you import `sync`, refer to it directly
    |
119 -         next: fn(alloc::sync::Arc<arc_repro::ExampleDependency>) -> T,
119 +         next: fn(sync::Arc<arc_repro::ExampleDependency>) -> T,