feat: kotlin codegen

lib/codegen/codegen.dart

@@ -15,7 +15,7 @@ class Codegen {
       case CodegenLanguage.dartHttp:
         return DartHttpCodeGen().getCode(requestModel, defaultUriScheme);
       case CodegenLanguage.kotlinOkHttp:
-        return KotlinOkHttpCodeGen().getCode(requestModel);
+        return KotlinOkHttpCodeGen().getCode(requestModel, defaultUriScheme);
       case CodegenLanguage.pythonHttpClient:
         return PythonHttpClientCodeGen()
             .getCode(requestModel, defaultUriScheme);

lib/codegen/kotlin/pkg_okhttp.dart

@@ -1,79 +1,157 @@
+import 'dart:convert';
 import 'package:apidash/consts.dart';
-
+import 'package:jinja/jinja.dart' as jj;
+import 'package:apidash/utils/utils.dart' show getValidRequestUri, rowsToMap;
 import '../../models/request_model.dart';
 
 class KotlinOkHttpCodeGen {
-  final String headerSnippet = """import okhttp3.MediaType.Companion.toMediaType
+  final String kTemplateStart = """import okhttp3.OkHttpClient
-import okhttp3.MultipartBody
+import okhttp3.Request{{importForQuery}}{{importForBody}}
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
-import okhttp3.RequestBody.Companion.asRequestBody
-import java.io.File
-import java.util.concurrent.TimeUnit
 
+fun main() {
     val client = OkHttpClient()
+
 """;
 
-  final String footerSnippet = """  .build()
+  final String kStringImportForQuery = """
+
+import okhttp3.HttpUrl.Companion.toHttpUrl""";
+
+  final String kStringImportForBody = """
+
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.MediaType.Companion.toMediaType""";
+
+  final String kTemplateUrl = '''
+
+    val url = "{{url}}"
+
+''';
+
+  final String kTemplateUrlQuery = '''
+
+    val url = "{{url}}".toHttpUrl().newBuilder()
+{{params}}        .build()
+
+''';
+
+  String kTemplateRequestBody = '''
+
+    val mediaType = "{{contentType}}".toMediaType()
+
+    val body = """{{body}}""".toRequestBody(mediaType)
+
+''';
+
+  final String kStringRequestStart = """
+
+    val request = Request.Builder()
+        .url(url)
+""";
+
+  final String kTemplateRequestEnd = """
+        .{{method}}({{hasBody}})
+        .build()
+
     val response = client.newCall(request).execute()
 
-println(response.body!!.string())
+    println(response.code)
+    println(response.body?.string())
+}
+
 """;
-  String getCode(RequestModel requestModel) {
+
+  String? getCode(
+    RequestModel requestModel,
+    String defaultUriScheme,
+  ) {
+    try {
       String result = "";
-    result = result + headerSnippet;
+      bool hasHeaders = false;
-    if (requestModel.method != HTTPVerb.get &&
+      bool hasQuery = false;
-        requestModel.method != HTTPVerb.head) {
+      bool hasBody = false;
-      result =
+
-          """${result}val mediaType = "${requestModel.requestBodyContentType == ContentType.json ? "application/json" : "text/plain"}".toMediaType()
+      String url = requestModel.url;
-val body = "${requestModel.requestBody}".toRequestBody(mediaType)\n""";
+      if (!url.contains("://") && url.isNotEmpty) {
+        url = "$defaultUriScheme://$url";
       }
-    result = "${result}val request = Request.Builder()\n";
 
-    result = "$result  .url(\"${requestModel.url}\")\n";
+      var rec = getValidRequestUri(url, requestModel.requestParams);
-    result = result + addQueryParams(requestModel);
+      Uri? uri = rec.$1;
-    result = result + addRequestMethod(requestModel);
-    result = result + addHeaders(requestModel);
-    result = result + footerSnippet;
 
+      if (uri != null) {
+        String url = "${uri.scheme}://${uri.authority}${uri.path}";
+
+        if (uri.hasQuery) {
+          var params = uri.queryParameters;
+          if (params.isNotEmpty) {
+            hasQuery = true;
+            var templateParams = jj.Template(kTemplateUrlQuery);
+            result += templateParams
+                .render({"url": url, "params": getQueryParams(params)});
+          }
+        }
+        if (!hasQuery) {
+          var templateUrl = jj.Template(kTemplateUrl);
+          result += templateUrl.render({"url": url});
+        }
+
+        var method = requestModel.method;
+        var requestBody = requestModel.requestBody;
+        if (kMethodsWithBody.contains(method) && requestBody != null) {
+          var contentLength = utf8.encode(requestBody).length;
+          if (contentLength > 0) {
+            hasBody = true;
+            String contentType =
+                kContentTypeMap[requestModel.requestBodyContentType] ?? "";
+            var templateBody = jj.Template(kTemplateRequestBody);
+            result += templateBody
+                .render({"contentType": contentType, "body": requestBody});
+          }
+        }
+
+        var templateStart = jj.Template(kTemplateStart);
+        var stringStart = templateStart.render({
+          "importForQuery": hasQuery ? kStringImportForQuery : "",
+          "importForBody": hasBody ? kStringImportForBody : ""
+        });
+
+        result = stringStart + result;
+        result += kStringRequestStart;
+
+        var headersList = requestModel.requestHeaders;
+        if (headersList != null) {
+          var headers = rowsToMap(requestModel.requestHeaders) ?? {};
+          if (headers.isNotEmpty) {
+            hasHeaders = true;
+            result += getHeaders(headers);
+          }
+        }
+
+        var templateRequestEnd = jj.Template(kTemplateRequestEnd);
+        result += templateRequestEnd.render({
+          "method": method.name.toLowerCase(),
+          "hasBody": hasBody ? "body" : "",
+        });
+      }
       return result;
+    } catch (e) {
+      return null;
+    }
   }
 
-  String addQueryParams(RequestModel requestModel) {
+  String getQueryParams(Map<String, String> params) {
     String result = "";
-    if (requestModel.requestParams == null) {
+    for (final k in params.keys) {
-      return result;
+      result = """$result        .addQueryParameter("$k", "${params[k]}")\n""";
-    }
-    for (final queryParam in requestModel.requestParams!) {
-      result =
-          """$result  .addQueryParameter("${queryParam.name}", "${queryParam.value}")\n""";
     }
     return result;
   }
 
-  String addHeaders(RequestModel requestModel) {
+  String getHeaders(Map<String, String> headers) {
     String result = "";
-    if (requestModel.requestHeaders == null) {
+    for (final k in headers.keys) {
-      return result;
+      result = """$result        .addHeader("$k", "${headers[k]}")\n""";
-    }
-    for (final header in requestModel.requestHeaders!) {
-      result = """$result  .addHeader("${header.name}", "${header.value}")\n""";
-    }
-    return result;
-  }
-
-  String addRequestMethod(RequestModel requestModel) {
-    String result = "";
-    if (requestModel.method != HTTPVerb.get &&
-        requestModel.method != HTTPVerb.head &&
-        requestModel.method != HTTPVerb.delete) {
-      result = """$result  .${requestModel.method.name}(body)\n""";
-    } else if (requestModel.method == HTTPVerb.head) {
-      result = """$result  .${requestModel.method.name}()\n""";
-    }
-    if (requestModel.method == HTTPVerb.delete) {
-      result = """$result  .method("DELETE", body)\n""";
     }
     return result;
   }

test/codegen/kotlin_okhttp_codegen_test.dart

@@ -3,124 +3,498 @@ import 'package:test/test.dart';
 import '../request_models.dart';
 
 void main() {
-  group('KotlinOkHttpCodeGen', () {
   final kotlinOkHttpCodeGen = KotlinOkHttpCodeGen();
 
-    test('getCode returns valid code for GET request', () {
+  group('GET Request', () {
-      const expectedCode = r"""import okhttp3.MediaType.Companion.toMediaType
+    test('GET 1', () {
-import okhttp3.MultipartBody
+      const expectedCode = r"""import okhttp3.OkHttpClient
-import okhttp3.OkHttpClient
 import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
-import okhttp3.RequestBody.Companion.asRequestBody
-import java.io.File
-import java.util.concurrent.TimeUnit
 
+fun main() {
     val client = OkHttpClient()
+
+    val url = "https://api.foss42.com"
+
     val request = Request.Builder()
-  .url("https://api.foss42.com")
+        .url(url)
+        .get()
         .build()
+
     val response = client.newCall(request).execute()
 
-println(response.body!!.string())
+    println(response.code)
+    println(response.body?.string())
+}
 """;
-      expect(kotlinOkHttpCodeGen.getCode(requestModelGet1), expectedCode);
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet1, "https"), expectedCode);
     });
 
-    test('getCode returns valid code for POST request', () {
+    test('GET 2', () {
-      const expectedCode = r"""import okhttp3.MediaType.Companion.toMediaType
+      const expectedCode = r"""import okhttp3.OkHttpClient
-import okhttp3.MultipartBody
-import okhttp3.OkHttpClient
 import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.RequestBody.Companion.asRequestBody
-import java.io.File
-import java.util.concurrent.TimeUnit
 
+fun main() {
     val client = OkHttpClient()
-val mediaType = "application/json".toMediaType()
+
-val body = "{"text": "IS Upper"}".toRequestBody(mediaType)
+    val url = "https://api.foss42.com/country/data".toHttpUrl().newBuilder()
-val request = Request.Builder()
+        .addQueryParameter("code", "US")
-  .url("https://api.foss42.com/case/lower")
-  .post(body)
         .build()
+
+    val request = Request.Builder()
+        .url(url)
+        .get()
+        .build()
+
     val response = client.newCall(request).execute()
 
-println(response.body!!.string())
+    println(response.code)
+    println(response.body?.string())
+}
 """;
-      expect(kotlinOkHttpCodeGen.getCode(requestModelPost1), expectedCode);
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet2, "https"), expectedCode);
     });
 
-    test('getCode returns valid code for DELETE request', () {
+    test('GET 3', () {
-      const expectedCode = r"""import okhttp3.MediaType.Companion.toMediaType
+      const expectedCode = r"""import okhttp3.OkHttpClient
-import okhttp3.MultipartBody
-import okhttp3.OkHttpClient
 import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.RequestBody.Companion.asRequestBody
-import java.io.File
-import java.util.concurrent.TimeUnit
 
+fun main() {
     val client = OkHttpClient()
-val mediaType = "application/json".toMediaType()
+
-val body = "{"title": "foo","body": "bar","userId": 1}".toRequestBody(mediaType)
+    val url = "https://api.foss42.com/country/data".toHttpUrl().newBuilder()
-val request = Request.Builder()
+        .addQueryParameter("code", "IND")
-  .url("https://jsonplaceholder.typicode.com/posts/1")
-  .method("DELETE", body)
         .build()
+
+    val request = Request.Builder()
+        .url(url)
+        .get()
+        .build()
+
     val response = client.newCall(request).execute()
 
-println(response.body!!.string())
+    println(response.code)
+    println(response.body?.string())
+}
 """;
-      expect(kotlinOkHttpCodeGen.getCode(requestModelDelete1), expectedCode);
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet3, "https"), expectedCode);
     });
 
-    test('getCode returns valid code for HEAD request', () {
+    test('GET 4', () {
-      const expectedCode = """import okhttp3.MediaType.Companion.toMediaType
+      const expectedCode = r"""import okhttp3.OkHttpClient
-import okhttp3.MultipartBody
-import okhttp3.OkHttpClient
 import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.RequestBody.Companion.asRequestBody
-import java.io.File
-import java.util.concurrent.TimeUnit
 
+fun main() {
     val client = OkHttpClient()
+
+    val url = "https://api.foss42.com/humanize/social".toHttpUrl().newBuilder()
+        .addQueryParameter("num", "8700000")
+        .addQueryParameter("digits", "3")
+        .addQueryParameter("system", "SS")
+        .addQueryParameter("add_space", "true")
+        .addQueryParameter("trailing_zeros", "true")
+        .build()
+
     val request = Request.Builder()
-  .url("https://jsonplaceholder.typicode.com/posts/1")
+        .url(url)
+        .get()
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+""";
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet4, "https"), expectedCode);
+    });
+
+    test('GET 5', () {
+      const expectedCode = r"""import okhttp3.OkHttpClient
+import okhttp3.Request
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.github.com/repos/foss42/apidash"
+
+    val request = Request.Builder()
+        .url(url)
+        .addHeader("User-Agent", "Test Agent")
+        .get()
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+""";
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet5, "https"), expectedCode);
+    });
+
+    test('GET 6', () {
+      const expectedCode = r"""import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.HttpUrl.Companion.toHttpUrl
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.github.com/repos/foss42/apidash".toHttpUrl().newBuilder()
+        .addQueryParameter("raw", "true")
+        .build()
+
+    val request = Request.Builder()
+        .url(url)
+        .addHeader("User-Agent", "Test Agent")
+        .get()
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+""";
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet6, "https"), expectedCode);
+    });
+
+    test('GET 7', () {
+      const expectedCode = r"""import okhttp3.OkHttpClient
+import okhttp3.Request
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.foss42.com"
+
+    val request = Request.Builder()
+        .url(url)
+        .get()
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+""";
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet7, "https"), expectedCode);
+    });
+
+    test('GET 8', () {
+      const expectedCode = r"""import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.HttpUrl.Companion.toHttpUrl
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.github.com/repos/foss42/apidash".toHttpUrl().newBuilder()
+        .addQueryParameter("raw", "true")
+        .build()
+
+    val request = Request.Builder()
+        .url(url)
+        .addHeader("User-Agent", "Test Agent")
+        .get()
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+""";
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelGet8, "https"), expectedCode);
+    });
+  });
+
+  group('HEAD Request', () {
+    test('HEAD 1', () {
+      const expectedCode = r"""import okhttp3.OkHttpClient
+import okhttp3.Request
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.foss42.com"
+
+    val request = Request.Builder()
+        .url(url)
         .head()
         .build()
+
     val response = client.newCall(request).execute()
 
-println(response.body!!.string())
+    println(response.code)
+    println(response.body?.string())
+}
 """;
-      expect(kotlinOkHttpCodeGen.getCode(requestModelHead1), expectedCode);
+      expect(kotlinOkHttpCodeGen.getCode(requestModelHead1, "https"),
+          expectedCode);
     });
 
-    test(
+    test('HEAD 2', () {
-        'getCode returns valid code for requests with headers and query parameters',
+      const expectedCode = r"""import okhttp3.OkHttpClient
-        () {
-      const expectedCode = """import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.MultipartBody
-import okhttp3.OkHttpClient
 import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
-import okhttp3.RequestBody.Companion.asRequestBody
-import java.io.File
-import java.util.concurrent.TimeUnit
 
+fun main() {
     val client = OkHttpClient()
+
+    val url = "http://api.foss42.com"
+
     val request = Request.Builder()
-  .url("https://jsonplaceholder.typicode.com/posts")
+        .url(url)
-  .addQueryParameter("userId", "1")
+        .head()
-  .addHeader("Custom-Header-1", "Value-1")
-  .addHeader("Custom-Header-2", "Value-2")
         .build()
+
     val response = client.newCall(request).execute()
 
-println(response.body!!.string())
+    println(response.code)
+    println(response.body?.string())
+}
 """;
-      expect(kotlinOkHttpCodeGen.getCode(requestModelGet2), expectedCode);
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelHead2, "http"), expectedCode);
+    });
+  });
+
+  group('POST Request', () {
+    test('POST 1', () {
+      const expectedCode = r'''import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.MediaType.Companion.toMediaType
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.foss42.com/case/lower"
+
+    val mediaType = "text/plain".toMediaType()
+
+    val body = """{
+"text": "I LOVE Flutter"
+}""".toRequestBody(mediaType)
+
+    val request = Request.Builder()
+        .url(url)
+        .post(body)
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+''';
+      expect(kotlinOkHttpCodeGen.getCode(requestModelPost1, "https"),
+          expectedCode);
+    });
+
+    test('POST 2', () {
+      const expectedCode = r'''import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.MediaType.Companion.toMediaType
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.foss42.com/case/lower"
+
+    val mediaType = "application/json".toMediaType()
+
+    val body = """{
+"text": "I LOVE Flutter"
+}""".toRequestBody(mediaType)
+
+    val request = Request.Builder()
+        .url(url)
+        .post(body)
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+''';
+      expect(kotlinOkHttpCodeGen.getCode(requestModelPost2, "https"),
+          expectedCode);
+    });
+
+    test('POST 3', () {
+      const expectedCode = r'''import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.MediaType.Companion.toMediaType
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://api.foss42.com/case/lower"
+
+    val mediaType = "application/json".toMediaType()
+
+    val body = """{
+"text": "I LOVE Flutter"
+}""".toRequestBody(mediaType)
+
+    val request = Request.Builder()
+        .url(url)
+        .addHeader("User-Agent", "Test Agent")
+        .post(body)
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+''';
+      expect(kotlinOkHttpCodeGen.getCode(requestModelPost3, "https"),
+          expectedCode);
+    });
+  });
+  group('PUT Request', () {
+    test('PUT 1', () {
+      const expectedCode = r'''import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.MediaType.Companion.toMediaType
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://reqres.in/api/users/2"
+
+    val mediaType = "application/json".toMediaType()
+
+    val body = """{
+"name": "morpheus",
+"job": "zion resident"
+}""".toRequestBody(mediaType)
+
+    val request = Request.Builder()
+        .url(url)
+        .put(body)
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+''';
+      expect(
+          kotlinOkHttpCodeGen.getCode(requestModelPut1, "https"), expectedCode);
+    });
+  });
+
+  group('PATCH Request', () {
+    test('PATCH 1', () {
+      const expectedCode = r'''import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.MediaType.Companion.toMediaType
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://reqres.in/api/users/2"
+
+    val mediaType = "application/json".toMediaType()
+
+    val body = """{
+"name": "marfeus",
+"job": "accountant"
+}""".toRequestBody(mediaType)
+
+    val request = Request.Builder()
+        .url(url)
+        .patch(body)
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+''';
+      expect(kotlinOkHttpCodeGen.getCode(requestModelPatch1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('DELETE Request', () {
+    test('DELETE 1', () {
+      const expectedCode = r"""import okhttp3.OkHttpClient
+import okhttp3.Request
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://reqres.in/api/users/2"
+
+    val request = Request.Builder()
+        .url(url)
+        .delete()
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+""";
+      expect(kotlinOkHttpCodeGen.getCode(requestModelDelete1, "https"),
+          expectedCode);
+    });
+
+    test('DELETE 2', () {
+      const expectedCode = r'''import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.MediaType.Companion.toMediaType
+
+fun main() {
+    val client = OkHttpClient()
+
+    val url = "https://reqres.in/api/users/2"
+
+    val mediaType = "application/json".toMediaType()
+
+    val body = """{
+"name": "marfeus",
+"job": "accountant"
+}""".toRequestBody(mediaType)
+
+    val request = Request.Builder()
+        .url(url)
+        .delete(body)
+        .build()
+
+    val response = client.newCall(request).execute()
+
+    println(response.code)
+    println(response.body?.string())
+}
+''';
+      expect(kotlinOkHttpCodeGen.getCode(requestModelDelete2, "https"),
+          expectedCode);
     });
   });
 }