[VID-4] Complete refactoring.

.github/workflows/ci.yml

@@ -9,20 +9,31 @@ concurrency:
 jobs:
   ci:
     name: 🧪 Test & lint
+    environment: ci
     runs-on: ubuntu-latest
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
-      - name: Commit message lint
-        uses: wagoid/commitlint-github-action@v4
+#      - name: Commit message lint
+#        uses: wagoid/commitlint-github-action@v4
+
+      - name: Setup JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'corretto'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
 
       - name: Test
         env:
-          STREAM_KEY: ${{ secrets.STREAM_KEY }}
-          STREAM_SECRET: ${{ secrets.STREAM_SECRET }}
+          STREAM_BASE_URL: ${{ vars.STREAM_BASE_URL }}
+          STREAM_API_KEY: ${{ vars.STREAM_API_KEY }}
+          STREAM_API_SECRET: ${{ secrets.STREAM_API_SECRET }}
         run: |
           ./gradlew spotlessCheck --no-daemon
-          ./gradlew jacocoTestReport --no-daemon
+          ./gradlew build --info --no-daemon

.github/workflows/release.yml

@@ -32,8 +32,8 @@ jobs:
           sudo bash -c "echo '$GPG_KEY_CONTENTS' | base64 -d > '$SIGNING_SECRET_KEY_RING_FILE'"
           ./gradlew publishReleasePublicationToSonatypeRepository --no-daemon --max-workers 1 closeAndReleaseSonatypeStagingRepository
         env:
-          STREAM_KEY: ${{ secrets.STREAM_KEY }}
-          STREAM_SECRET: ${{ secrets.STREAM_SECRET }}
+          STREAM_API_KEY: ${{ vars.STREAM_API_KEY }}
+          STREAM_API_SECRET: ${{ secrets.STREAM_API_SECRET }}
           GPG_KEY_CONTENTS: ${{ secrets.GPG_KEY_CONTENTS }}
           OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
           OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}

.github/workflows/scheduled_test.yml

@@ -14,8 +14,8 @@ jobs:
 
       - name: Run tests
         env:
-          STREAM_KEY: ${{ secrets.STREAM_KEY }}
-          STREAM_SECRET: ${{ secrets.STREAM_SECRET }}
+          STREAM_API_KEY: ${{ vars.STREAM_API_KEY }}
+          STREAM_API_SECRET: ${{ secrets.STREAM_API_SECRET }}
         run: |
           # Retry 3 times because tests can be flaky
           for _ in 1 2 3;

.gitignore

@@ -48,4 +48,6 @@ gradle-app.setting
 .classpath
 
 ## project specific
-/local.properties
+/local.properties
+
+.idea

CONTRIBUTING.md

@@ -67,7 +67,7 @@ They are data objects. They correspond to the formats of the API responses.
 
 ### Service interfaces
 
-They are Retrofit service interfaces, that describe the API endpoints.
+They are the interfaces that define the API endpoints. 
 
 ### The StreamServiceGenerator class
 

README.md

@@ -14,119 +14,102 @@ Check out our:
 
 ## Installation
 
-To install the Stream Client Library, run the following command:
-
-```sh
-pip install getstream
+```gradle
+dependencies {
+    implementation "io.getstream:stream-sdk-java:$stream_version"
+}
 ```
 
-## Usage
+## ✨ Getting started
 
-To get started, you need to import the `Stream` class from the library and create a new instance with your API key and secret:
+### Configuration
 
-```python
-from getstream import Stream
+To configure the SDK you need to provide required properties.
 
-client = Stream(api_key="your_api_key", api_secret="your_api_secret")
-```
+| Property               | ENV                | Default                      | Required |
+| ---------------------- |--------------------|------------------------------| -------- |
+| io.getstream.apiKey    | STREAM_API_KEY     | -                            | Yes      |
+| io.getstream.apiSecret | STREAM_API_SECRET  | -                            | Yes      |
+| io.getstream.timeout   | STREAM_API_TIMEOUT | 10000                          | No       |
 
 ### Users and Authentication
 
-```python
-from getstream.models import UserRequest
-
-# sync two users using the update_users method, both users will get insert or updated
-client.upsert_users(
-    UserRequest(
-        id="tommaso-id", name="tommaso", role="admin", custom={"country": "NL"}
-    ),
-    UserRequest(
-        id="thierry-id", name="thierry", role="admin", custom={"country": "US"}
-    ),
-)
-
-# Create a JWT token for the user to connect client-side (e.g. browser/mobile app)
-token = client.create_token("tommaso-id")
+```java
+import io.getstream.models.UserRequest;
+
+// sync two users using the UpdateUsers method, both users will get inserted or updated
+List<UserRequest> userRequests =
+    List.of(
+        UserRequest.builder()
+            .id("tommaso-id")
+            .name("tommaso")
+            .role("admin")
+            .custom(Map.of("country", "NL"))
+            .build(),
+        UserRequest.builder()
+            .id("thierry-id")
+            .name("thierry")
+            .custom(Map.of("country", "US"))
+            .build());
+
+UpdateUsersRequest updateUsersRequest =
+    UpdateUsersRequest.builder()
+        .users(userRequests.stream().collect(Collectors.toMap(UserRequest::getId, x -> x)))
+        .build();
+
+client.common().UpdateUsers(updateUsersRequest).request();
+
+// Create a JWT token for the user to connect client-side (e.g. browser/mobile app)
+// token expires in 24 hours
+String token = createToken(userId, 24*60*60);
 ```
 
-### Video API - Calls
-
-To create a video call, use the `client.video.call` method:
-
-```python
-import uuid
-from getstream.models import (
-    CallRequest,
-    MemberRequest,
-)
-
-call = client.video.call("default", uuid.uuid4())
-call.get_or_create(
-    data=CallRequest(
-        created_by_id="tommaso-id",
-        members=[
-            MemberRequest(user_id="thierry-id"),
-            MemberRequest(user_id="tommaso-id"),
-        ],
-    ),
-)
-```
-
-### App configuration
-
-```python
-# Video: update settings for a call type
-
-# Chat: update settings for a channel type
+// Token does not expire
+String token = createToken(userId);
 ```
 
+### Video API - Calls
 
-### Chat API - Channels
-
-To work with chat sessions, use the `client.chat` object and implement the desired chat methods in the `Chat` class:
-
-```python
-chat_instance = client.chat
+To create a video call, use the `client.video.call` method:
 
-# TODO: implement and call chat-related methods with chat_instance
+```java
+var testCall = new Call("default", UUID.randomUUID().toString());
+
+// create call if it doesn't exist or get the existing one
+call.getOrCreate(
+    GetOrCreateCallRequest.builder()
+        .data(
+            CallRequest.builder()
+                .createdByID("sacha")
+                .members(members)
+                .custom(Map.of("color", "blue"))
+                .build())
+        .build());
 ```
 
 ## Development
 
-We use poetry to manage dependencies and run tests. It's a package manager for Python that allows you to declare the libraries your project depends on and manage them.
-To install the development dependencies, run the following command:
+To run tests, create the `local.properties` file using the `local.properties.example` and adjust it to have valid API credentials:
 
 ```sh
-poetry install
-pre-commit install
+cp local.properties.example local.properties
 ```
 
-To activate the virtual environment, run the following command:
-
-```sh
-poetry shell
-```
+Then run the tests:
 
-To run tests, create a `.env` using the `.env.example` and adjust it to have valid API credentials
 ```sh
-poetry run pytest tests/ getstream/
+ ./gradlew test
 ```
 
-Before pushing changes make sure to have git hooks installed correctly, so that you get linting done locally `pre-commit install`
-
-You can also run the code formatting yourself if needed:
+Format the code:
 
 ```sh
-poetry run ruff format getstream/ tests/
+./gradlew spotlessApply
 ```
 
-### Writing new tests
-
-pytest is used to run tests and to inject fixtures, simple tests can be written as simple python functions making assert calls. Make sure to have a look at the available test fixtures under `tests/fixtures.py`
-
 ### Generate code from spec
 
-To regenerate the Python source from OpenAPI, just run the `./generate.sh` script from this repo.
+To regenerate the Java source from OpenAPI, just run the `./generate.sh` script from this repo.
 
 > [!NOTE]
 > Code generation currently relies on tooling that is not publicly available, only Stream devs can regenerate SDK source code from the OpenAPI spec.

generate.sh

@@ -16,4 +16,4 @@ set -ex
 # format generated code
 ./gradlew spotlessApply
 
-./gradlew build
+./gradlew build -x test