feat: add codegen for rust(reqwest)

lib/codegen/codegen.dart

@@ -5,6 +5,7 @@ import 'dart/dio.dart';
 import 'kotlin/okhttp.dart';
 import 'python/http_client.dart';
 import 'python/requests.dart';
+import 'rust/reqwest.dart';
 import 'js/axios.dart';
 import 'js/fetch.dart';
 import 'others/har.dart';
@@ -42,6 +43,8 @@ class Codegen {
             .getCode(requestModel, defaultUriScheme);
       case CodegenLanguage.pythonRequests:
         return PythonRequestsCodeGen().getCode(requestModel, defaultUriScheme);
+      case CodegenLanguage.rustReqwest:
+        return RustReqwestCodeGen().getCode(requestModel, defaultUriScheme);
     }
   }
 }

lib/codegen/rust/reqwest.dart

@@ -0,0 +1,220 @@
+import 'dart:io';
+import 'dart:convert';
+import 'package:jinja/jinja.dart' as jj;
+import 'package:apidash/consts.dart';
+import 'package:apidash/utils/utils.dart'
+    show getNewUuid, getValidRequestUri, padMultilineString, stripUriParams;
+import 'package:apidash/models/models.dart' show RequestModel;
+
+class RustReqwestCodeGen {
+  final String kTemplateStart =
+      """fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "{{url}}";
+
+""";
+
+  String kTemplateParams = """
+
+  let params = {{params}};
+
+""";
+  int kParamsPadding = 9;
+
+  String kTemplateBody = """
+
+  let payload = b"{{body}}";
+
+""";
+
+  String kTemplateJson = """
+
+  let payload = serde_json::json!({{body}});
+
+""";
+
+  String kTemplateHeaders = """
+
+  let header_str = r#"{{headers}}"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+""";
+  String kTemplateFormHeaderContentType = '''
+multipart/form-data; boundary={{boundary}}''';
+
+  int kHeadersPadding = 10;
+
+  String kTemplateRequest = """
+
+  let response = client.{{method}}(url)
+""";
+
+  final String kStringFormDataBody = r'''
+  #[derive(serde::Deserialize)]
+  struct FormDataItem {
+      name: String,
+      value: String,
+      field_type: String,
+  }
+  let data_str = r#"{{fields_list}}"#; 
+  let form_data_items: Vec<FormDataItem> = serde_json::from_str(data_str).unwrap(); 
+  
+  let mut form = reqwest::blocking::multipart::Form::new();
+  
+  for item in form_data_items {
+      if item.field_type == "text" {
+          form = form.text(item.name, item.value);
+      } else if item.field_type == "file" {
+          form = form.file(item.name, &item.value)?; 
+      }
+  }
+''';
+
+  String kStringRequestParams = """\n    .query(&params)""";
+
+  String kStringRequestBody = """\n    .body(payload.to_vec())""";
+
+  String kStringRequestJson = """\n    .json(&payload)""";
+
+  String kStringRequestForm = """\n    .multipart(form)""";
+
+  String kStringRequestHeaders = """\n    .headers(headers)""";
+
+  final String kStringRequestEnd = """\n    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+
+  String? getCode(
+    RequestModel requestModel,
+    String defaultUriScheme,
+  ) {
+    try {
+      String result = "";
+      bool hasQuery = false;
+      bool hasHeaders = false;
+      bool hasBody = false;
+      bool hasJsonBody = false;
+      String uuid = getNewUuid();
+
+      String url = requestModel.url;
+      if (!url.contains("://") && url.isNotEmpty) {
+        url = "$defaultUriScheme://$url";
+      }
+
+      var rec = getValidRequestUri(
+        url,
+        requestModel.enabledRequestParams,
+      );
+      Uri? uri = rec.$1;
+      if (uri != null) {
+        var templateStartUrl = jj.Template(kTemplateStart);
+        result += templateStartUrl.render({
+          "url": stripUriParams(uri),
+          'isFormDataRequest': requestModel.isFormDataRequest,
+          'isJson': requestModel.requestBodyContentType == ContentType.json
+        });
+
+        if (uri.hasQuery) {
+          var params = uri.queryParameters;
+          if (params.isNotEmpty) {
+            hasQuery = true;
+            var tupleStrings = params.entries
+                .map((entry) => '("${entry.key}", "${entry.value}")')
+                .toList();
+            var paramsString = "[${tupleStrings.join(', ')}]";
+            var templateParams = jj.Template(kTemplateParams);
+            paramsString = padMultilineString(paramsString, kParamsPadding);
+            result += templateParams.render({"params": paramsString});
+          }
+        }
+
+        var method = requestModel.method;
+        var requestBody = requestModel.requestBody;
+        if (kMethodsWithBody.contains(method) && requestBody != null) {
+          var contentLength = utf8.encode(requestBody).length;
+          if (contentLength > 0) {
+            if (requestModel.requestBodyContentType == ContentType.json) {
+              hasJsonBody = true;
+              var templateBody = jj.Template(kTemplateJson);
+              result += templateBody.render({"body": requestBody});
+            } else if (!requestModel.isFormDataRequest) {
+              hasBody = true;
+              var templateBody = jj.Template(kTemplateBody);
+              result += templateBody.render({"body": requestBody});
+            }
+          }
+        }
+
+        var headersList = requestModel.enabledRequestHeaders;
+        if (headersList != null || hasBody) {
+          var headers = requestModel.enabledHeadersMap;
+          if (requestModel.isFormDataRequest) {
+            var formHeaderTemplate =
+                jj.Template(kTemplateFormHeaderContentType);
+            headers[HttpHeaders.contentTypeHeader] = formHeaderTemplate.render({
+              "boundary": uuid,
+            });
+          }
+          if (headers.isNotEmpty || hasBody) {
+            hasHeaders = true;
+            if (hasBody) {
+              headers[HttpHeaders.contentTypeHeader] =
+                  requestModel.requestBodyContentType.header;
+            }
+            var headersString = kEncoder.convert(headers);
+            headersString = padMultilineString(headersString, kHeadersPadding);
+            var templateHeaders = jj.Template(kTemplateHeaders);
+            result += templateHeaders.render({"headers": headersString});
+          }
+        }
+        if (requestModel.isFormDataRequest) {
+          var formDataBodyData = jj.Template(kStringFormDataBody);
+          result += formDataBodyData.render(
+            {
+              "fields_list": json.encode(requestModel.formDataMapList),
+              "boundary": uuid,
+            },
+          );
+        }
+        var templateRequest = jj.Template(kTemplateRequest);
+        result += templateRequest.render({
+          "method": method.name.toLowerCase(),
+        });
+
+        if (hasQuery) {
+          result += kStringRequestParams;
+        }
+
+        if (hasBody && !requestModel.isFormDataRequest) {
+          result += kStringRequestBody;
+        }
+
+        if (hasJsonBody) {
+          result += kStringRequestJson;
+        }
+
+        if (requestModel.isFormDataRequest) {
+          result += kStringRequestForm;
+        }
+
+        if (hasHeaders || requestModel.isFormDataRequest) {
+          result += kStringRequestHeaders;
+        }
+
+        result += kStringRequestEnd;
+      }
+      return result;
+    } catch (e) {
+      return null;
+    }
+  }
+}

lib/consts.dart

@@ -268,7 +268,8 @@ enum CodegenLanguage {
   nodejsFetch("node.js (fetch)", "javascript", "js"),
   kotlinOkHttp("Kotlin (okhttp3)", "java", "kt"),
   pythonHttpClient("Python (http.client)", "python", "py"),
-  pythonRequests("Python (requests)", "python", "py");
+  pythonRequests("Python (requests)", "python", "py"),
+  rustReqwest("Rust (reqwest)", "rust", "rs");
 
   const CodegenLanguage(this.label, this.codeHighlightLang, this.ext);
   final String label;

test/codegen/rust_reqwest_codegen_test.dart

@@ -0,0 +1,546 @@
+import 'package:apidash/codegen/rust/reqwest.dart';
+import '../request_models.dart';
+import 'package:test/test.dart';
+
+void main() {
+  final rustReqwestCodeGen = RustReqwestCodeGen();
+
+  group('GET Request', () {
+    test('GET 1', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com";
+
+  let response = client.get(url)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet1, "https"), expectedCode);
+    });
+
+    test('GET 2', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/country/data";
+
+  let params = [("code", "US")];
+
+  let response = client.get(url)
+    .query(&params)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet2, "https"), expectedCode);
+    });
+
+    test('GET 3', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/country/data";
+
+  let params = [("code", "IND")];
+
+  let response = client.get(url)
+    .query(&params)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet3, "https"), expectedCode);
+    });
+
+    test('GET 4', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/humanize/social";
+
+  let params = [("num", "8700000"), ("digits", "3"), ("system", "SS"), ("add_space", "true"), ("trailing_zeros", "true")];
+
+  let response = client.get(url)
+    .query(&params)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet4, "https"), expectedCode);
+    });
+
+    test('GET 5', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.github.com/repos/foss42/apidash";
+
+  let header_str = r#"{
+            "User-Agent": "Test Agent"
+          }"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+  let response = client.get(url)
+    .headers(headers)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet5, "https"), expectedCode);
+    });
+
+    test('GET 6', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.github.com/repos/foss42/apidash";
+
+  let params = [("raw", "true")];
+
+  let header_str = r#"{
+            "User-Agent": "Test Agent"
+          }"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+  let response = client.get(url)
+    .query(&params)
+    .headers(headers)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet6, "https"), expectedCode);
+    });
+
+    test('GET 7', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com";
+
+  let response = client.get(url)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet7, "https"), expectedCode);
+    });
+
+    test('GET 8', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.github.com/repos/foss42/apidash";
+
+  let params = [("raw", "true")];
+
+  let header_str = r#"{
+            "User-Agent": "Test Agent"
+          }"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+  let response = client.get(url)
+    .query(&params)
+    .headers(headers)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet8, "https"), expectedCode);
+    });
+
+    test('GET 9', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/humanize/social";
+
+  let params = [("num", "8700000"), ("add_space", "true")];
+
+  let response = client.get(url)
+    .query(&params)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet9, "https"), expectedCode);
+    });
+
+    test('GET 10', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/humanize/social";
+
+  let header_str = r#"{
+            "User-Agent": "Test Agent"
+          }"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+  let response = client.get(url)
+    .headers(headers)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(
+            requestModelGet10,
+            "https",
+          ),
+          expectedCode);
+    });
+
+    test('GET 11', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/humanize/social";
+
+  let params = [("num", "8700000"), ("digits", "3")];
+
+  let header_str = r#"{
+            "User-Agent": "Test Agent"
+          }"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+  let response = client.get(url)
+    .query(&params)
+    .headers(headers)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet11, "https"), expectedCode);
+    });
+
+    test('GET 12', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/humanize/social";
+
+  let response = client.get(url)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelGet12, "https"), expectedCode);
+    });
+  });
+
+  group('HEAD Request', () {
+    test('HEAD 1', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com";
+
+  let response = client.head(url)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelHead1, "https"), expectedCode);
+    });
+
+    test('HEAD 2', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "http://api.foss42.com";
+
+  let response = client.head(url)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelHead2, "http"), expectedCode);
+    });
+  });
+
+  group('POST Request', () {
+    test('POST 1', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/case/lower";
+
+  let payload = b"{
+"text": "I LOVE Flutter"
+}";
+
+  let header_str = r#"{
+            "content-type": "text/plain"
+          }"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+  let response = client.post(url)
+    .body(payload.to_vec())
+    .headers(headers)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelPost1, "https"), expectedCode);
+    });
+
+    test('POST 2', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/case/lower";
+
+  let payload = serde_json::json!({
+"text": "I LOVE Flutter"
+});
+
+  let response = client.post(url)
+    .json(&payload)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelPost2, "https"), expectedCode);
+    });
+
+    test('POST 3', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://api.foss42.com/case/lower";
+
+  let payload = serde_json::json!({
+"text": "I LOVE Flutter"
+});
+
+  let header_str = r#"{
+            "User-Agent": "Test Agent"
+          }"#;
+    let headers_map: std::collections::HashMap<&str, &str> = serde_json::from_str(header_str)?; // Deserialize as &str
+    let mut headers = reqwest::header::HeaderMap::new();
+    for (key, val) in headers_map {
+        headers.insert(key, reqwest::header::HeaderValue::from_str(val)?);
+    }
+
+  let response = client.post(url)
+    .json(&payload)
+    .headers(headers)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelPost3, "https"), expectedCode);
+    });
+  });
+
+  group('PUT Request', () {
+    test('PUT 1', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://reqres.in/api/users/2";
+
+  let payload = serde_json::json!({
+"name": "morpheus",
+"job": "zion resident"
+});
+
+  let response = client.put(url)
+    .json(&payload)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(
+          rustReqwestCodeGen.getCode(requestModelPut1, "https"), expectedCode);
+    });
+  });
+
+  group('PATCH Request', () {
+    test('PATCH 1', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://reqres.in/api/users/2";
+
+  let payload = serde_json::json!({
+"name": "marfeus",
+"job": "accountant"
+});
+
+  let response = client.patch(url)
+    .json(&payload)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(rustReqwestCodeGen.getCode(requestModelPatch1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('DELETE Request', () {
+    test('DELETE 1', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://reqres.in/api/users/2";
+
+  let response = client.delete(url)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(rustReqwestCodeGen.getCode(requestModelDelete1, "https"),
+          expectedCode);
+    });
+
+    test('DELETE 2', () {
+      const expectedCode =
+          r"""fn main() -> Result<(), Box<dyn std::error::Error>> {
+  let client = reqwest::blocking::Client::new();
+  let url = "https://reqres.in/api/users/2";
+
+  let payload = serde_json::json!({
+"name": "marfeus",
+"job": "accountant"
+});
+
+  let response = client.delete(url)
+    .json(&payload)
+    .send()?;
+
+  println!("Status Code: {}", response.status()); 
+  println!("Response Body: {}", response.text()?);
+
+  Ok(())
+}
+""";
+      expect(rustReqwestCodeGen.getCode(requestModelDelete2, "https"),
+          expectedCode);
+    });
+  });
+}