@arrirpc/codegen-rust 0.54.0 → 0.57.0

package/README.md

@@ -37,31 +37,101 @@ cargo add arri_client
 
 ## Using the generated code
 
-### Initialize the client
+All of the generated procedures in this client will be async functions, so you will need an async runtime like [tokio](https://tokio.rs/)
+
+### Initializing the client
 
 ```rust
 let config = ArriClientConfig {
     http_client: reqwest::Client::new(),
     base_url: "https://example.com".to_string(),
-    // this function will run before every request
-    headers: || {
-        let mut header_map = Hashmap::<&'static str, &'static str>::new();
-        header_map.insert("some-header", "some-header-value");
-        header_map
-    }
+    headers: Hashmap::new(),
 }
-let client = MyClient::create(&config);
+let client = MyClient::create(config);
 
+// start calling procedures
 client.my_procedure().await;
 ```
 
 The root client will be a struct containing all of the services and procedures. If you only need a particular service you can initialize just that service.
 
 ```rust
-let users_service = MyClientUsersService(&config);
+let users_service = MyClientUsersService(config);
 users_service.some_procedure().await;
 ```
 
+### Updating Headers
+
+For instances that you need to update the http headers (like in the case of an expired auth token), you can call the `update_headers()` function. When called, changes will propagate to all nested subservices.
+
+```rust
+client.update_headers(new_headers);
+```
+
+Be aware that if `update_headers()` is called from a subservice it will not propagate up to the parent service(s).
+
+```rust
+client.subservice.update_headers(new_headers);
+
+// this will still use the original headers
+client.do_something();
+```
+
+`update_headers()` be also be called across threads.
+
+```rust
+let mut headers: HashMap<&'static str, String> = HashMap::new();
+let config = ArriClientConfig {
+    http_client: reqwest::Client::new(),
+    base_url: "https://example.com".to_string(),
+    headers: headers.clone(),
+}
+let client = Arc::new(MyClient::create(config));
+tokio::spawn(async move {
+    loop {
+        client.do_something().await;
+    }
+});
+tokio::spawn(async move {
+    loop {
+        client.do_another_thing().await;
+    }
+});
+
+// wait two seconds then change the headers
+tokio::time::sleep(Duration::from_millis(2000)).await;
+headers.insert("hello", "world".to_string());
+client.update_headers(headers.clone());
+// now both threads will start using the updated headers on their next loop
+```
+
+### Calling SSE Procedures
+
+```rust
+let mut msg_count = 0;
+let mut open_count = 0;
+client
+    .users
+    .watch_user(
+        &mut |event, controller| match event {
+            SseEvent::Message(msg) => {
+                msg_count += 1;
+                printl("NEW_MESSAGE: {:?}", msg);
+            }
+            SSeEvent::Error(err) => {
+                // call abort to close the event stream
+                controller.abort()
+            }
+            SseEvent::Open => {
+                open_count += 1;
+            }
+            SseEvent::Close => {}
+        },
+        None, // max_retry_count (u64)
+        None, // max_retry_interval (u64)
+    ).await;
+```
+
 ### Using the generated types
 
 All the generated types will have the following methods implemented

package/dist/index.cjs

@@ -1544,15 +1544,7 @@ function rustRpcFromSchema(schema, context) {
   }
 }
 function rustHttpRpcFromSchema(schema, context) {
-  if (schema.isEventStream) {
-    console.warn(
-      `[rust-codegen] SSE is not supported at this time. Skipping ${context.instancePath}.`
-    );
-    return "";
-  }
   const functionName = getFunctionName(context.instancePath);
-  const params = schema.params ? validRustName(schema.params) : void 0;
-  const response = schema.response ? validRustName(schema.response) : void 0;
   let leading = "";
   if (schema.description) {
     leading += formatDescriptionComment(schema.description);
@@ -1561,16 +1553,44 @@ function rustHttpRpcFromSchema(schema, context) {
   if (schema.isDeprecated) {
     leading += "#[deprecated]\n";
   }
-  return `${leading}pub async fn ${functionName} (
-        self: &Self,
+  const params = schema.params ? validRustName(schema.params) : void 0;
+  const response = schema.response ? validRustName(schema.response) : void 0;
+  if (schema.isEventStream) {
+    return `${leading}pub async fn ${functionName}<OnEvent>(
+            &self,
+            ${params ? `params: ${context.typeNamePrefix}${params},` : ""}
+            on_event: &mut OnEvent,
+            max_retry_count: Option<u64>,
+            max_retry_interval: Option<u64>,
+        ) where
+            OnEvent: FnMut(SseEvent<${response ? `${context.typeNamePrefix}${response}` : "EmptyArriModel"}>, &mut SseController) + std::marker::Send + std::marker::Sync,
+        {
+            parsed_arri_sse_request(
+                ArriParsedSseRequestOptions {
+                    client: &self._config.http_client,
+                    url: format!("{}${schema.path}", &self._config.base_url),
+                    method: reqwest::Method::${schema.method.toUpperCase()},
+                    headers: self._config.headers.clone(),
+                    client_version: "${context.clientVersion}".to_string(),
+                    max_retry_count,
+                    max_retry_interval,
+                },
+                ${params ? `Some(params)` : "None::<EmptyArriModel>"},
+                on_event,
+            )
+            .await;
+        }`;
+  }
+  return `${leading}pub async fn ${functionName}(
+        &self,
         ${params ? `params: ${context.typeNamePrefix}${params},` : ""}
     ) -> Result<${context.typeNamePrefix}${response ?? "()"}, ArriServerError> {
         parsed_arri_request(
             ArriParsedRequestOptions {
-                http_client: &self.config.http_client,
-                url: format!("{}${schema.path}", &self.config.base_url),
+                http_client: &self._config.http_client,
+                url: format!("{}${schema.path}", &self._config.base_url),
                 method: reqwest::Method::${schema.method.toUpperCase()},
-                headers: self.config.headers,
+                headers: self._config.headers.clone(),
                 client_version: "${context.clientVersion}".to_string(),
             },
             ${params ? `Some(params)` : "None::<EmptyArriModel>"},
@@ -1637,23 +1657,30 @@ function rustServiceFromSchema(schema, context) {
       `[rust-codegen] Invalid schema at /procedures/${context.instancePath}.`
     );
   }
+  const paramSuffix = subServices.length > 0 ? ".clone()" : "";
   return {
     name: serviceName,
-    content: `pub struct ${serviceName}<'a> {
-    config: &'a ArriClientConfig,
-${subServices.map((service) => `    pub ${service.key}: ${service.name}<'a>,`).join("\n")}
+    content: `#[derive(Clone)]
+pub struct ${serviceName} {
+    _config: InternalArriClientConfig,
+${subServices.map((service) => `    pub ${service.key}: ${service.name},`).join("\n")}
 }
 
-impl<'a> ArriClientService<'a> for ${serviceName}<'a> {
-    fn create(config: &'a ArriClientConfig) -> Self {
+impl ArriClientService for ${serviceName} {
+    fn create(config: ArriClientConfig) -> Self {
         Self {
-            config: &config,
-${subServices.map((service) => `            ${service.key}: ${service.name}::create(config),`).join("\n")}
+            _config: InternalArriClientConfig::from(config${paramSuffix}),
+${subServices.map((service, index) => `            ${service.key}: ${service.name}::create(config${index === subServices.length - 1 ? "" : ".clone()"}),`).join("\n")}
         }
     }
+    fn update_headers(&self, headers: HashMap<&'static str, String>) {
+        let mut unwrapped_headers = self._config.headers.write().unwrap();
+        *unwrapped_headers = headers.clone();
+${subServices.map((service, index) => `        self.${service.key}.update_headers(headers${index === subServices.length - 1 ? "" : ".clone()"});`).join("\n")}
+    }
 }
 
-impl ${serviceName}<'_> {
+impl ${serviceName} {
 ${rpcParts.join("\n")}
 }
 
@@ -1892,35 +1919,51 @@ use arri_client::{
     utils::{serialize_date_time, serialize_string},
     ArriEnum, ArriModel,
 };
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 ${modelParts.join("\n\n")}`;
   }
   const clientName = validRustName(context.clientName);
-  return `#![allow(dead_code, unused_imports, unused_variables, unconditional_recursion, deprecated)]
+  const paramSuffix = subServices.length > 0 ? ".clone()" : "";
+  return `#![allow(
+    dead_code,
+    unused_imports,
+    unused_variables,
+    unconditional_recursion,
+    deprecated
+)]
 use arri_client::{
     chrono::{DateTime, FixedOffset},
-    parsed_arri_request, reqwest, serde_json,
+    parsed_arri_request,
+    reqwest::{self, Request},
+    serde_json::{self, Map},
+    sse::{parsed_arri_sse_request, ArriParsedSseRequestOptions, SseController, SseEvent},
     utils::{serialize_date_time, serialize_string},
     ArriClientConfig, ArriClientService, ArriEnum, ArriModel, ArriParsedRequestOptions,
-    ArriServerError, EmptyArriModel,
+    ArriServerError, EmptyArriModel, InternalArriClientConfig,
 };
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 
-pub struct ${clientName}<'a> {
-    config: &'a ArriClientConfig,
-${subServices.map((service) => `    pub ${service.key}: ${service.name}<'a>,`).join("\n")}
+#[derive(Clone)]
+pub struct ${clientName} {
+    _config: InternalArriClientConfig,
+${subServices.map((service) => `    pub ${service.key}: ${service.name},`).join("\n")}
 }
 
-impl<'a> ArriClientService<'a> for ${clientName}<'a> {
-    fn create(config: &'a ArriClientConfig) -> Self {
+impl ArriClientService for ${clientName} {
+    fn create(config: ArriClientConfig) -> Self {
         Self {
-            config: &config,
-${subServices.map((service) => `            ${service.key}: ${service.name}::create(config),`).join("\n")}
+            _config: InternalArriClientConfig::from(config${paramSuffix}),
+${subServices.map((service, index) => `            ${service.key}: ${service.name}::create(config${index === subServices.length - 1 ? "" : ".clone()"}),`).join("\n")}
         }
     }
+    fn update_headers(&self, headers: HashMap<&'static str, String>) {
+       let mut unwrapped_headers = self._config.headers.write().unwrap();
+        *unwrapped_headers = headers.clone();
+${subServices.map((service, index) => `        self.${service.key}.update_headers(headers${index === subServices.length - 1 ? "" : ".clone()"});`).join("\n")}
+    }
 }
 
-impl ${clientName}<'_> {
+impl ${clientName} {
 ${rpcParts.join("\n")}
 }
 

package/dist/index.mjs

@@ -1536,15 +1536,7 @@ function rustRpcFromSchema(schema, context) {
   }
 }
 function rustHttpRpcFromSchema(schema, context) {
-  if (schema.isEventStream) {
-    console.warn(
-      `[rust-codegen] SSE is not supported at this time. Skipping ${context.instancePath}.`
-    );
-    return "";
-  }
   const functionName = getFunctionName(context.instancePath);
-  const params = schema.params ? validRustName(schema.params) : void 0;
-  const response = schema.response ? validRustName(schema.response) : void 0;
   let leading = "";
   if (schema.description) {
     leading += formatDescriptionComment(schema.description);
@@ -1553,16 +1545,44 @@ function rustHttpRpcFromSchema(schema, context) {
   if (schema.isDeprecated) {
     leading += "#[deprecated]\n";
   }
-  return `${leading}pub async fn ${functionName} (
-        self: &Self,
+  const params = schema.params ? validRustName(schema.params) : void 0;
+  const response = schema.response ? validRustName(schema.response) : void 0;
+  if (schema.isEventStream) {
+    return `${leading}pub async fn ${functionName}<OnEvent>(
+            &self,
+            ${params ? `params: ${context.typeNamePrefix}${params},` : ""}
+            on_event: &mut OnEvent,
+            max_retry_count: Option<u64>,
+            max_retry_interval: Option<u64>,
+        ) where
+            OnEvent: FnMut(SseEvent<${response ? `${context.typeNamePrefix}${response}` : "EmptyArriModel"}>, &mut SseController) + std::marker::Send + std::marker::Sync,
+        {
+            parsed_arri_sse_request(
+                ArriParsedSseRequestOptions {
+                    client: &self._config.http_client,
+                    url: format!("{}${schema.path}", &self._config.base_url),
+                    method: reqwest::Method::${schema.method.toUpperCase()},
+                    headers: self._config.headers.clone(),
+                    client_version: "${context.clientVersion}".to_string(),
+                    max_retry_count,
+                    max_retry_interval,
+                },
+                ${params ? `Some(params)` : "None::<EmptyArriModel>"},
+                on_event,
+            )
+            .await;
+        }`;
+  }
+  return `${leading}pub async fn ${functionName}(
+        &self,
         ${params ? `params: ${context.typeNamePrefix}${params},` : ""}
     ) -> Result<${context.typeNamePrefix}${response ?? "()"}, ArriServerError> {
         parsed_arri_request(
             ArriParsedRequestOptions {
-                http_client: &self.config.http_client,
-                url: format!("{}${schema.path}", &self.config.base_url),
+                http_client: &self._config.http_client,
+                url: format!("{}${schema.path}", &self._config.base_url),
                 method: reqwest::Method::${schema.method.toUpperCase()},
-                headers: self.config.headers,
+                headers: self._config.headers.clone(),
                 client_version: "${context.clientVersion}".to_string(),
             },
             ${params ? `Some(params)` : "None::<EmptyArriModel>"},
@@ -1629,23 +1649,30 @@ function rustServiceFromSchema(schema, context) {
       `[rust-codegen] Invalid schema at /procedures/${context.instancePath}.`
     );
   }
+  const paramSuffix = subServices.length > 0 ? ".clone()" : "";
   return {
     name: serviceName,
-    content: `pub struct ${serviceName}<'a> {
-    config: &'a ArriClientConfig,
-${subServices.map((service) => `    pub ${service.key}: ${service.name}<'a>,`).join("\n")}
+    content: `#[derive(Clone)]
+pub struct ${serviceName} {
+    _config: InternalArriClientConfig,
+${subServices.map((service) => `    pub ${service.key}: ${service.name},`).join("\n")}
 }
 
-impl<'a> ArriClientService<'a> for ${serviceName}<'a> {
-    fn create(config: &'a ArriClientConfig) -> Self {
+impl ArriClientService for ${serviceName} {
+    fn create(config: ArriClientConfig) -> Self {
         Self {
-            config: &config,
-${subServices.map((service) => `            ${service.key}: ${service.name}::create(config),`).join("\n")}
+            _config: InternalArriClientConfig::from(config${paramSuffix}),
+${subServices.map((service, index) => `            ${service.key}: ${service.name}::create(config${index === subServices.length - 1 ? "" : ".clone()"}),`).join("\n")}
         }
     }
+    fn update_headers(&self, headers: HashMap<&'static str, String>) {
+        let mut unwrapped_headers = self._config.headers.write().unwrap();
+        *unwrapped_headers = headers.clone();
+${subServices.map((service, index) => `        self.${service.key}.update_headers(headers${index === subServices.length - 1 ? "" : ".clone()"});`).join("\n")}
+    }
 }
 
-impl ${serviceName}<'_> {
+impl ${serviceName} {
 ${rpcParts.join("\n")}
 }
 
@@ -1884,35 +1911,51 @@ use arri_client::{
     utils::{serialize_date_time, serialize_string},
     ArriEnum, ArriModel,
 };
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 ${modelParts.join("\n\n")}`;
   }
   const clientName = validRustName(context.clientName);
-  return `#![allow(dead_code, unused_imports, unused_variables, unconditional_recursion, deprecated)]
+  const paramSuffix = subServices.length > 0 ? ".clone()" : "";
+  return `#![allow(
+    dead_code,
+    unused_imports,
+    unused_variables,
+    unconditional_recursion,
+    deprecated
+)]
 use arri_client::{
     chrono::{DateTime, FixedOffset},
-    parsed_arri_request, reqwest, serde_json,
+    parsed_arri_request,
+    reqwest::{self, Request},
+    serde_json::{self, Map},
+    sse::{parsed_arri_sse_request, ArriParsedSseRequestOptions, SseController, SseEvent},
     utils::{serialize_date_time, serialize_string},
     ArriClientConfig, ArriClientService, ArriEnum, ArriModel, ArriParsedRequestOptions,
-    ArriServerError, EmptyArriModel,
+    ArriServerError, EmptyArriModel, InternalArriClientConfig,
 };
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 
-pub struct ${clientName}<'a> {
-    config: &'a ArriClientConfig,
-${subServices.map((service) => `    pub ${service.key}: ${service.name}<'a>,`).join("\n")}
+#[derive(Clone)]
+pub struct ${clientName} {
+    _config: InternalArriClientConfig,
+${subServices.map((service) => `    pub ${service.key}: ${service.name},`).join("\n")}
 }
 
-impl<'a> ArriClientService<'a> for ${clientName}<'a> {
-    fn create(config: &'a ArriClientConfig) -> Self {
+impl ArriClientService for ${clientName} {
+    fn create(config: ArriClientConfig) -> Self {
         Self {
-            config: &config,
-${subServices.map((service) => `            ${service.key}: ${service.name}::create(config),`).join("\n")}
+            _config: InternalArriClientConfig::from(config${paramSuffix}),
+${subServices.map((service, index) => `            ${service.key}: ${service.name}::create(config${index === subServices.length - 1 ? "" : ".clone()"}),`).join("\n")}
         }
     }
+    fn update_headers(&self, headers: HashMap<&'static str, String>) {
+       let mut unwrapped_headers = self._config.headers.write().unwrap();
+        *unwrapped_headers = headers.clone();
+${subServices.map((service, index) => `        self.${service.key}.update_headers(headers${index === subServices.length - 1 ? "" : ".clone()"});`).join("\n")}
+    }
 }
 
-impl ${clientName}<'_> {
+impl ${clientName} {
 ${rpcParts.join("\n")}
 }
 

package/package.json

@@ -22,10 +22,10 @@
   ],
   "dependencies": {
     "pathe": "^1.1.2",
-    "@arrirpc/codegen-utils": "0.54.0"
+    "@arrirpc/codegen-utils": "0.57.0"
   },
   "devDependencies": {
-    "@arrirpc/schema": "0.54.0"
+    "@arrirpc/schema": "0.57.0"
   },
-  "version": "0.54.0"
+  "version": "0.57.0"
 }