Refactorization of the SDK

.code-samples.meilisearch.yaml

@@ -6,7 +6,7 @@
 get_one_index_1: |-
   client.getIndex("movies");
 list_all_indexes_1: |-
-  client.getAllIndexes();
+  client.getIndexes();
 create_an_index_1: |-
   client.createIndex("movies", "id");
 update_an_index_1: |-

.github/workflows/tests.yml

@@ -26,8 +26,8 @@ jobs:
         cache: gradle
     - name: Grant execute permission for gradlew
       run: chmod +x gradlew
-    - name: Meilisearch (latest version) setup with Docker
-      run: docker run -d -p 7700:7700 getmeili/meilisearch:latest meilisearch --no-analytics --master-key='masterKey'
+    - name: Meilisearch (v0.27.2 version) setup with Docker
+      run: docker run -d -p 7700:7700 getmeili/meilisearch:v0.27.2 meilisearch --no-analytics --master-key='masterKey'
     - name: Build and run unit and integration tests
       run: ./gradlew build integrationTest
     - name: Archive test report

CONTRIBUTING.md

@@ -32,7 +32,7 @@ You can set up your local environment natively or using `docker`, check out the
 
 Example of running all the checks with docker:
 ```bash
-docker-compose run --rm package bash -c "./gradlew build && ./gradlew test IntegrationTest"
+docker-compose run --rm package bash -c "./gradlew build && ./gradlew build integrationTest"
 ```
 
 To install dependencies:

README.md

@@ -223,109 +223,41 @@ index.search(
 
 ### JSON <!-- omit in toc -->
 
-#### Basic JSON <!-- omit in toc -->
+#### Default JSON `GsonJsonHandler` <!-- omit in toc -->
 
-The default JSON can be created by calling the default constructor of `JsonbJsonHandler` class which will create a config of type `JsonbConfig` and using this config. It will initialize the mapper variable by calling the create method of `JsonbBuilder` class.
+The default JSON library is `Gson`. You can however use another library with the `JsonHandler` Class.
 
-#### Creating a Custom `GsonJsonHandler` <!-- omit in toc -->
+*Notes*: We strongly recommend using the `Gson` library.
 
-To create a custom JSON handler, create an object of GsonJsonHandler and send the GSON object in the parameterized constructor.<br>
+#### Using `JacksonJsonHandler` <!-- omit in toc -->
 
-```java
-Gson gson = new GsonBuilder()
-             .disableHtmlEscaping()
-             .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
-             .setPrettyPrinting()
-             .serializeNulls()
-             .create();
-private GsonJsonHandler jsonGson = new GsonJsonHandler(gson);
-jsonGson.encode("your_data");
-```
-
-#### Creating a Custom `JacksonJsonHandler` <!-- omit in toc -->
-
-Another method is to create an object of `JacksonJsonHandler` and set the required parameters. The supported option is an object of `ObjectMapper`. It's passed as a parameter to the `JacksonJsonHandler`’s parameterized constructor. This is used to initialize the mapper variable.
-
-The mapper variable is responsible for the encoding and decoding of the JSON.
-
-Using the custom JSON:
-
-```java
-Config config = new Config("http://localhost:7700", "masterKey");
-HttpAsyncClient client = HttpAsyncClients.createDefault();
-ApacheHttpClient client = new ApacheHttpClient(config, client);
-private final JsonHandler jsonHandler = new JacksonJsonHandler(new ObjectMapper());
-private final RequestFactory requestFactory = new BasicRequestFactory(jsonHandler);
-private final GenericServiceTemplate serviceTemplate = new GenericServiceTemplate(client, jsonHandler, requestFactory);
-
-private final ServiceTemplate serviceTemplate;
-serviceTemplate.getProcessor().encode("your_data");
-```
-
-### Creating a Custom `JsonbJsonHandler <!-- omit in toc -->
-
-Another method of creating a JSON handler is to create an object of `JsonbJsonHandler` and send the `Jsonb` object to the parameterized constructor.
+Initialize your `Config` and assign it a new `JacksonJsonHandler` object as `JsonHandler`.
+Set up your `Client` with it.
 
 ```java
-Jsonb jsonb = JsonbBuilder.create();
-private JsonbJsonHandler jsonbHandler = new JsonbJsonHandler(jsonb);
-jsonbHandler.encode("your_data");
-```
-
-### Custom Client <!-- omit in toc -->
+import com.meilisearch.sdk.json.JacksonJsonHandler;
 
-To create a custom `Client` handler, create an object of `Client` and set the required parameters.
-
-A `Config` object should be passed, containing your host URL and your API key.
-
-```java
 Config config = new Config("http://localhost:7700", "masterKey");
-return new Client(config);
+config.setJsonHandler(new JacksonJsonHandler());
+Client client = new Client(config);
 ```
 
-The `Client(config)` constructor sets the config instance to the member variable. It also sets the 3 other instances namely `gson()`, `IndexesHandler(config)` and `DumpHandler(config)`.
+#### Use a Custom `JsonHandler` <!-- omit in toc -->
 
-Using the custom `Client`:
+To create your own JSON handler, you must conform to the `JsonHandler` interface by implementing its two methods.
 
 ```java
-Config config = new Config("http://localhost:7700", "masterKey");
-HttpAsyncClient client = HttpAsyncClients.createDefault();
-ApacheHttpClient customClient = new ApacheHttpClient(config, client);
-customClient.index("movies").search("American ninja");
-```
-
-#### Custom Http Request <!-- omit in toc -->
-
-To create a custom HTTP request, create an object of `BasicHttpRequest` and set the required parameters.
+    String encode(Object o) throws Exception;
 
-The supported options are as follows:
-
-1. HTTP method: a `String` that can be set as following values: `HEAD`, `GET`, `POST`, `PUT`, or `DELETE`.
-2. Path: a `String` corresponding to the endpoint of the API.
-3. Headers: a `Map<String,String>` containing the header parameters in the form of key-value pair.
-4. Content: the `String` of your content.
-
-```java
-return new BasicHttpRequest(
-                    method,
-                    path,
-                    headers,
-                    content == null ? null : this.jsonHandler.encode(content));
+    <T> T decode(Object o, Class<?> targetClass, Class<?>... parameters) throws Exception;
 ```
 
-Alternatively, there is an interface `RequestFactory` which has a method `create`.<br>
-In order to call this method, create an object of `RequestFactory` and call the method by passing the required parameters.
-
-Using the custom Http Request:
+ Then create your client by initializing your `Config` with your new handler.
 
 ```java
-public interface RequestFactory {
-    <T> HttpRequest<?> create(
-            HttpMethod method, String path, Map<String, String> headers, T content);
- }
-
-private final RequestFactory requestFactory;
-requestFactory.create(HttpMethod.GET, "/health", Collections.emptyMap(), {"id":"3"});
+Config config = new Config("http://localhost:7700", "masterKey");
+config.setJsonHandler(new myJsonHandler());
+Client client = new Client(config);
 ```
 
 ## 🤖 Compatibility with Meilisearch

build.gradle

@@ -45,7 +45,6 @@ dependencies {
 	implementation 'com.google.code.gson:gson:2.9.0'
 	implementation 'org.json:json:20220320'
 	// https://mvnrepository.com/artifact/org.apache.httpcomponents.client5/httpclient5
-	compileOnly group: 'org.apache.httpcomponents.client5', name: 'httpclient5', version: '5.1.3'
 	compileOnly 'com.squareup.okhttp3:okhttp:4.10.0'
 
 	// Use JUnit test framework
@@ -56,9 +55,7 @@ dependencies {
 	testImplementation 'org.hamcrest:hamcrest:2.2'
 
 	// https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind
-	compileOnly group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.13.2.2'
-	compileOnly group: 'jakarta.json.bind', name: 'jakarta.json.bind-api', version: '2.0.0'
-	testImplementation group: 'org.eclipse', name: 'yasson', version: '2.0.4'
+	compileOnly group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.13.4'
 
 	// Lombok
 	compileOnly 'org.projectlombok:lombok:1.18.24'