Merge pull request #20 from sashirestela/19-remove-code-related-to-bodypart

Remove Code Related to BodyPart

Author: sashirestela

README.md

@@ -152,7 +152,7 @@ var cleverClient = CleverClient.builder()
 
 ### Supported Response Types
 
-The reponse types are determined from the method responses. We don't need any annotation for that. We have five response types: [Stream](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/stream/Stream.html) of objects, [List](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html) of objects, Generic of object, Single object, and Plain Text, and all of them can be asynchronous or synchronous. For async responses you have to use the Java class [CompletableFuture](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CompletableFuture.html).
+The reponse types are determined from the method responses. We don't need any annotation for that. We have five response types: [Stream](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/stream/Stream.html) of objects, [List](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html) of objects, Generic of object, Single object, [Binary](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html) object, and Plain Text, and all of them can be asynchronous or synchronous. For async responses you have to use the Java class [CompletableFuture](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CompletableFuture.html).
 
 | Method Response                     | Sync/Async | Response Type                           |
 |-------------------------------------|------------|-----------------------------------------|
@@ -164,6 +164,8 @@ The reponse types are determined from the method responses. We don't need any an
 | Generic\<Object>                    | Sync       | Custom Generic Class of Object          |
 | CompletableFuture\<Object>          | Async      | Single Object                           |
 | Object                              | Sync       | Single Object                           |
+| CompletableFuture\<InputStream>     | Async      | Binary Object                           |
+| InputStream                         | Sync       | Binary Object                           |
 | CompletableFuture\<String>          | Async      | Plain Text                              |
 | String                              | Sync       | Plain Text                              |
 
@@ -172,29 +174,29 @@ The reponse types are determined from the method responses. We don't need any an
 You can create interface default methods to execute special requirements such as pre/post processing before/after calling annotated regular methods. For example in the following interface definition, we have two regular methods with POST annotation which are called from another two default methods. In those defaults methods we are making some pre processing (in this case, modifying the request object) before calling the annotated methods:
 
 ```java
-@Resource("/v1/completions")
+@Resource("/v1/chat/completions")
 interface Completions {
 
-  default CompletableFuture<CompletionResponse> create(CompletionRequest completionRequest) {
-    completionRequest.setStream(false);
-    return notUseCreate(completionRequest);
-  }
+    @POST
+    Stream<ChatResponse> __createSyncStream(@Body ChatRequest chatRequest);
 
-  @POST
-  CompletableFuture<CompletionResponse> notUseCreate(@Body CompletionRequest completionRequest);
+    default Stream<ChatResponse> createSyncStream(ChatRequest chatRequest) {
+        var request = chatRequest.withStream(true);
+        return __createSyncStream(request);
+    }
 
-  default CompletableFuture<Stream<CompletionResponse>> createStream(CompletionRequest completionRequest) {
-    completionRequest.setStream(true);
-    return notUseCreateStream(completionRequest);
-  }
+    @POST
+    CompletableFuture<Stream<ChatResponse>> __createAsyncStream(@Body ChatRequest chatRequest);
 
-  @POST
-  CompletableFuture<Stream<CompletionResponse>> notUseCreateStream(@Body CompletionRequest completionRequest);
+    default CompletableFuture<Stream<ChatResponse>> createAsyncStream(ChatRequest chatRequest) {
+        var request = chatRequest.withStream(true);
+        return __createAsyncStream(request);
+    }
 
 }
 ```
 
-Note that we have named the annotated methods with the prefix "notUse" (notUseCreate, notUseCreateStream) just to indicate that we should not call them directly but should call the default ones (create, createStream).
+Note that we have named the annotated methods with the suffix "__" just to indicate that we should not call them directly but should call the default ones (those without the suffix).
 
 ## ✳ Examples
 
@@ -223,6 +225,8 @@ Some examples have been created in the folder [example](https://github.com/sashi
 
   * ```<className>``` is mandatory and must be one of the values:
     * BasicExample
+    * FileDownloadExample
+    * MultiServiceExample
     * StreamExample (This requires you have an OpenAI account and set the env variable OPENAI_API_TOKEN)
 
   * ```[logOptions]``` are optional and you can you use them to set:

pom.xml

@@ -6,7 +6,7 @@
 
   <groupId>io.github.sashirestela</groupId>
   <artifactId>cleverclient</artifactId>
-  <version>0.8.1</version>
+  <version>0.9.0</version>
   <packaging>jar</packaging>
 
   <name>cleverclient</name>

src/example/java/io/github/sashirestela/cleverclient/example/StreamExample.java

@@ -34,7 +34,6 @@ public static void main(String[] args) {
                 .messages(Arrays.asList(
                         new Message("user", "Write an article about AI, no more than 100 words.")))
                 .temperature(0.7)
-                .stream(true)
                 .build();
 
         showTitle("Example Create Synchronous Stream");

src/example/java/io/github/sashirestela/cleverclient/example/openai/ChatRequest.java

@@ -2,16 +2,16 @@
 
 import java.util.List;
 
-import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Getter;
+import lombok.With;
 
-@AllArgsConstructor
 @Getter
 @Builder
 public class ChatRequest {
     private String model;
     private List<Message> messages;
     private Double temperature;
+    @With
     private Boolean stream;
 }

src/example/java/io/github/sashirestela/cleverclient/example/openai/ChatService.java

@@ -11,9 +11,19 @@
 public interface ChatService {
 
     @POST
-    Stream<ChatResponse> createSyncStream(@Body ChatRequest chatRequest);
+    Stream<ChatResponse> __createSyncStream(@Body ChatRequest chatRequest);
+
+    default Stream<ChatResponse> createSyncStream(ChatRequest chatRequest) {
+        var request = chatRequest.withStream(true);
+        return __createSyncStream(request);
+    }
 
     @POST
-    CompletableFuture<Stream<ChatResponse>> createAsyncStream(@Body ChatRequest chatRequest);
+    CompletableFuture<Stream<ChatResponse>> __createAsyncStream(@Body ChatRequest chatRequest);
+
+    default CompletableFuture<Stream<ChatResponse>> createAsyncStream(ChatRequest chatRequest) {
+        var request = chatRequest.withStream(true);
+        return __createAsyncStream(request);
+    }
 
 }

src/main/java/io/github/sashirestela/cleverclient/annotation/BodyPart.java

@@ -5,7 +5,6 @@
 import java.net.http.HttpRequest;
 import java.net.http.HttpRequest.BodyPublisher;
 import java.net.http.HttpRequest.BodyPublishers;
-import java.util.List;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -25,12 +24,12 @@ public class HttpConnector {
     private String url;
     private String httpMethod;
     private ReturnType returnType;
-    private List<Object> bodyObjects;
+    private Object bodyObject;
     private boolean isMultipart;
     private String[] headersArray;
 
     public Object sendRequest() {
-        var bodyPublisher = createBodyPublisher(bodyObjects, isMultipart);
+        var bodyPublisher = createBodyPublisher(bodyObject, isMultipart);
         var responseClass = returnType.getBaseClass();
         HttpRequest httpRequest = null;
         if (headersArray.length > 0) {
@@ -53,18 +52,18 @@ public Object sendRequest() {
         }
     }
 
-    private BodyPublisher createBodyPublisher(List<Object> bodyObjects, boolean isMultipart) {
+    private BodyPublisher createBodyPublisher(Object bodyObject, boolean isMultipart) {
         BodyPublisher bodyPublisher = null;
-        if (bodyObjects.isEmpty()) {
+        if (bodyObject == null) {
             logger.debug("Body Request: (Empty)");
             bodyPublisher = BodyPublishers.noBody();
         } else if (isMultipart) {
-            var data = ReflectUtil.getMapFields(bodyObjects);
+            var data = ReflectUtil.getMapFields(bodyObject);
             var requestBytes = HttpMultipart.toByteArrays(data);
             logger.debug("Body Request: {}", data);
             bodyPublisher = BodyPublishers.ofByteArrays(requestBytes);
         } else {
-            var requestString = JsonUtil.objectsToJson(bodyObjects);
+            var requestString = JsonUtil.objectToJson(bodyObject);
             logger.debug("Body Request: {}", requestString);
             bodyPublisher = BodyPublishers.ofString(requestString);
         }

src/main/java/io/github/sashirestela/cleverclient/http/HttpConnector.java

@@ -5,10 +5,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
-import io.github.sashirestela.cleverclient.annotation.BodyPart;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -62,16 +59,16 @@ public Object resolve(Method method, Object[] arguments) {
         var httpMethod = methodMetadata.getHttpAnnotation().getName();
         var returnType = methodMetadata.getReturnType();
         var isMultipart = methodMetadata.isMultipart();
-        var bodyObjects = calculateBodyObjects(methodMetadata, arguments);
+        var bodyObject = calculateBodyObject(methodMetadata, arguments);
         var fullHeaders = new ArrayList<>(this.headers);
-        fullHeaders.addAll(calculateHeaderContentType(bodyObjects, isMultipart));
+        fullHeaders.addAll(calculateHeaderContentType(bodyObject, isMultipart));
         var fullHeadersArray = fullHeaders.toArray(new String[0]);
         var httpConnector = HttpConnector.builder()
                 .httpClient(httpClient)
                 .url(url)
                 .httpMethod(httpMethod)
                 .returnType(returnType)
-                .bodyObjects(bodyObjects)
+                .bodyObject(bodyObject)
                 .isMultipart(isMultipart)
                 .headersArray(fullHeadersArray)
                 .build();
@@ -104,23 +101,19 @@ private void validateMetadata() {
         });
     }
 
-    private List<Object> calculateBodyObjects(Metadata.Method methodMetadata, Object[] arguments) {
-        final var BODY      = Body.class.getSimpleName();
-        final var BODY_PART = BodyPart.class.getSimpleName();
-
-        return Stream.concat(
-                methodMetadata.getParametersByType().get(BODY).stream()
-                        .limit(1)
-                        .map(param -> arguments[param.getIndex()]),
-                methodMetadata.getParametersByType().get(BODY_PART).stream()
-                        .map(param -> arguments[param.getIndex()])
-                        .filter(arg -> !CommonUtil.isNullOrEmpty(arg))
-        ).collect(Collectors.toList());
+    private Object calculateBodyObject(Metadata.Method methodMetadata, Object[] arguments) {
+        final var BODY = Body.class.getSimpleName();
+        var indexBody = methodMetadata.getParametersByType().get(BODY)
+                .stream()
+                .map(Metadata.Parameter::getIndex)
+                .findFirst()
+                .orElse(-1);
+        return indexBody >= 0 ? arguments[indexBody] : null;
     }
 
-    private List<String> calculateHeaderContentType(List<Object> bodyObjects, boolean isMultipart) {
+    private List<String> calculateHeaderContentType(Object bodyObject, boolean isMultipart) {
         List<String> headerContentType = new ArrayList<>();
-        if (!bodyObjects.isEmpty()) {
+        if (bodyObject != null) {
             var contentType = isMultipart
                     ? Constant.TYPE_MULTIPART + Constant.BOUNDARY_TITLE + "\"" + Constant.BOUNDARY_VALUE + "\""
                     : Constant.TYPE_APP_JSON;

src/main/java/io/github/sashirestela/cleverclient/http/HttpProcessor.java

@@ -10,7 +10,7 @@ private Constant() {
     }
 
     public static final List<String> HTTP_METHODS = List.of("GET", "POST", "PUT", "DELETE");
-    public static final List<String> PARAMETER_TYPES = List.of("Path", "Query", "Body", "BodyPart");
+    public static final List<String> PARAMETER_TYPES = List.of("Path", "Query", "Body");
     public static final List<String> MULTIPART_AS_LIST = List.of("Multipart");
 
     public static final String JSON_EMPTY_CLASS = "{\"type\":\"object\",\"properties\":{}}";

src/main/java/io/github/sashirestela/cleverclient/util/Constant.java

@@ -7,7 +7,6 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
@@ -24,15 +23,6 @@ public static <T> T createProxy(Class<T> interfaceClass, InvocationHandler handl
                 handler);
     }
 
-    public static Map<String, Object> getMapFields(List<Object> objects) {
-        Map<String, Object> structure = new HashMap<>();
-        for (Object object : objects) {
-            structure.putAll(getMapFields(object));
-        }
-
-        return structure;
-    }
-
     public static Map<String, Object> getMapFields(Object object) {
         if (object instanceof Map) {
             return JsonUtil.objectToMap(object);