lint

benches/data_loader_bench.rs

@@ -10,8 +10,7 @@ use criterion::Criterion;
 use hyper::body::Bytes;
 use reqwest::Request;
 use tailcall::core::config::Batch;
-use tailcall::core::error::file;
-use tailcall::core::error::http;
+use tailcall::core::error::{file, http};
 use tailcall::core::http::{DataLoaderRequest, HttpDataLoader, Response};
 use tailcall::core::ir::IoId;
 use tailcall::core::runtime::TargetRuntime;

benches/impl_path_string_for_evaluation_context.rs

@@ -17,8 +17,7 @@ use reqwest::{Client, Request};
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
 use tailcall::core::blueprint::{Server, Upstream};
 use tailcall::core::cache::InMemoryCache;
-use tailcall::core::error::file;
-use tailcall::core::error::http;
+use tailcall::core::error::{file, http};
 use tailcall::core::http::{RequestContext, Response};
 use tailcall::core::ir::{EvaluationContext, ResolverContextLike};
 use tailcall::core::path::PathString;

src/cli/javascript/mod.rs

@@ -12,9 +12,7 @@ pub use runtime::Runtime;
 use crate::cli::Result;
 use crate::core::{blueprint, WorkerIO};
 
-pub fn init_worker_io<T, V>(
-    script: blueprint::Script,
-) -> Arc<dyn WorkerIO<T, V> + Send + Sync>
+pub fn init_worker_io<T, V>(script: blueprint::Script) -> Arc<dyn WorkerIO<T, V> + Send + Sync>
 where
     Runtime: WorkerIO<T, V>,
 {

src/cli/runtime/mod.rs

@@ -37,14 +37,7 @@ fn init_http_worker_io(
 
 fn init_resolver_worker_io(
     script: Option<blueprint::Script>,
-) -> Option<
-    Arc<
-        dyn WorkerIO<
-            async_graphql::Value,
-            async_graphql::Value,
-        >,
-    >,
-> {
+) -> Option<Arc<dyn WorkerIO<async_graphql::Value, async_graphql::Value>>> {
     #[cfg(feature = "js")]
     return Some(super::javascript::init_worker_io(script?));
     #[cfg(not(feature = "js"))]

src/cli/telemetry.rs

@@ -87,8 +87,7 @@ fn set_trace_provider(
             .install_batch(runtime::Tokio)?
             .provider()
             .ok_or(TraceError::Other(
-                Error::TelemetryTrace("Failed to instantiate OTLP provider".to_string())
-                    .into(),
+                Error::TelemetryTrace("Failed to instantiate OTLP provider".to_string()).into(),
             ))?,
         // Prometheus works only with metrics
         TelemetryExporter::Prometheus(_) => return Ok(None),

src/core/http/response.rs

@@ -7,8 +7,7 @@ use prost::Message;
 use tonic::Status;
 use tonic_types::Status as GrpcStatus;
 
-use crate::core::error::http;
-use crate::core::error::Error as CoreError;
+use crate::core::error::{http, Error as CoreError};
 use crate::core::grpc::protobuf::ProtobufOperation;
 use crate::core::ir::Error;
 

src/core/ir/error.rs

@@ -4,9 +4,7 @@ use std::sync::Arc;
 use async_graphql::{ErrorExtensions, Value as ConstValue};
 
 use crate::core::auth;
-use crate::core::error::http;
-use crate::core::error::worker;
-use crate::core::error::Error as CoreError;
+use crate::core::error::{http, worker, Error as CoreError};
 
 #[derive(Debug, thiserror::Error, Clone)]
 pub enum Error {

src/core/mod.rs

@@ -67,7 +67,11 @@ pub trait HttpIO: Sync + Send + 'static {
 
 #[async_trait::async_trait]
 pub trait FileIO: Send + Sync {
-    async fn write<'a>(&'a self, path: &'a str, content: &'a [u8]) -> Result<(), error::file::Error>;
+    async fn write<'a>(
+        &'a self,
+        path: &'a str,
+        content: &'a [u8],
+    ) -> Result<(), error::file::Error>;
     async fn read<'a>(&'a self, path: &'a str) -> Result<String, error::file::Error>;
 }
 

src/core/runtime.rs

@@ -31,8 +31,7 @@ pub struct TargetRuntime {
     /// Worker middleware for handling HTTP requests.
     pub cmd_worker: Option<Arc<dyn WorkerIO<Event, Command>>>,
     /// Worker middleware for resolving data.
-    pub worker:
-        Option<Arc<dyn WorkerIO<ConstValue, ConstValue>>>,
+    pub worker: Option<Arc<dyn WorkerIO<ConstValue, ConstValue>>>,
 }
 
 impl TargetRuntime {
@@ -151,7 +150,10 @@ pub mod test {
             Ok(())
         }
 
-        async fn read<'a>(&'a self, path: &'a str) -> crate::core::Result<String, error::file::Error> {
+        async fn read<'a>(
+            &'a self,
+            path: &'a str,
+        ) -> crate::core::Result<String, error::file::Error> {
             let mut file = tokio::fs::File::open(path).await?;
             let mut buffer = Vec::new();
             file.read_to_end(&mut buffer).await?;

tailcall-cloudflare/src/runtime.rs

@@ -13,10 +13,7 @@ fn init_env(env: Rc<worker::Env>) -> Arc<dyn EnvIO> {
     Arc::new(env::CloudflareEnv::init(env))
 }
 
-fn init_file(
-    env: Rc<worker::Env>,
-    bucket_id: &str,
-) -> anyhow::Result<Arc<dyn FileIO>> {
+fn init_file(env: Rc<worker::Env>, bucket_id: &str) -> anyhow::Result<Arc<dyn FileIO>> {
     Ok(Arc::new(file::CloudflareFileIO::init(env, bucket_id)?))
 }
 

tests/core/parse.rs

@@ -284,12 +284,12 @@ impl ExecutionSpec {
                 None
             };
 
-        let worker: Option<Arc<dyn WorkerIO<ConstValue, ConstValue>>> =
-            if let Some(script) = script {
-                Some(javascript::init_worker_io(script))
-            } else {
-                None
-            };
+        let worker: Option<Arc<dyn WorkerIO<ConstValue, ConstValue>>> = if let Some(script) = script
+        {
+            Some(javascript::init_worker_io(script))
+        } else {
+            None
+        };
 
         let runtime = TargetRuntime {
             http,

tests/server_spec.rs

@@ -15,11 +15,10 @@ pub mod test {
     use tailcall::core::blueprint::{Script, Upstream};
     use tailcall::core::cache::InMemoryCache;
     use tailcall::core::error::file;
-    use tailcall::core::error;
     use tailcall::core::http::Response;
     use tailcall::core::runtime::TargetRuntime;
     use tailcall::core::worker::{Command, Event};
-    use tailcall::core::{EnvIO, FileIO, HttpIO};
+    use tailcall::core::{error, EnvIO, FileIO, HttpIO};
     use tailcall_http_cache::HttpCacheManager;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
@@ -75,7 +74,10 @@ pub mod test {
 
     #[async_trait::async_trait]
     impl HttpIO for TestHttp {
-        async fn execute(&self, request: reqwest::Request) -> Result<Response<Bytes>, error::http::Error> {
+        async fn execute(
+            &self,
+            request: reqwest::Request,
+        ) -> Result<Response<Bytes>, error::http::Error> {
             let response = self.client.execute(request).await;
             Response::from_reqwest(
                 response?