feat: large refactor (#3)

- Pull in protos as submodule
- Internal types to ser/de with proto codegen for validations
- Full RPC coverage
- Refac of client organization
- Config classes
- All unary RPCs return futures
- Initial versions of "managed" streaming RPCs
- Gradle submodules

Author: sgbalogh

.github/workflows/ci.yml

@@ -2,9 +2,9 @@ name: Test and submit dependencies
 
 on:
   push:
-    branches: ["main"]
+    branches: [ "main" ]
   pull_request:
-    branches: ["main"]
+    branches: [ "main" ]
 
 jobs:
   build:

.github/workflows/publish.yml

@@ -2,7 +2,7 @@ name: Package and publish
 
 on:
   release:
-    types: [created]
+    types: [ created ]
 
 jobs:
   build:

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "proto"]
-	path = s2/src/main/proto
+	path = s2-internal/src/main/proto
 	url = https://github.com/s2-streamstore/s2-protos.git

README.md

@@ -3,14 +3,7 @@
 > [!WARNING]
 > This SDK is actively in development, and not officially supported yet!
 
-A Java SDK for interacting with the S2 streaming service. This SDK provides a hopefully convenientinterface for working with S2's gRPC-based streaming API.
-
-## Features
-
-- Fluent builder pattern for client configuration
-- Synchronous and asynchronous stream operations
-- Basin and stream management
-- Automatic channel management for basin switching
+A Java SDK for interacting with the S2 streaming service.
 
 ## Prerequisites
 
@@ -21,30 +14,34 @@ A Java SDK for interacting with the S2 streaming service. This SDK provides a ho
 ### Building from Source
 
 1. Clone the repository:
+
 ```bash
 git clone --recurse-submodules https://github.com/s2-streamstore/s2-sdk-java 
 cd s2-sdk-java
 ```
 
 2. Build the project:
+
 ```bash
 ./gradlew build
 ```
 
 3. Install to local Maven repository:
+
 ```bash
-./gradlew s2:publishToMavenLocal
+./gradlew publishToMavenLocal
 ```
 
 ### Using Maven (Local Published Artifact)
 
 Add this dependency to your `pom.xml`:
 
 ```xml
+
 <dependency>
-    <groupId>dev.s2</groupId>
-    <artifactId>s2</artifactId>
-    <version>0.0.1</version>
+  <groupId>dev.s2</groupId>
+  <artifactId>s2-sdk</artifactId>
+  <version>0.0.5-SNAPSHOT</version>
 </dependency>
 ```
 
@@ -54,120 +51,33 @@ Add this dependency to your `build.gradle.kts`:
 
 ```kotlin
 dependencies {
-    implementation("dev.s2:s2:0.0.1")
-}
-```
-
-## Quick Start
-
-Here's a simple example that demonstrates the basic usage of the SDK:
-
-```java
-import s2.services.Client;
-import s2.v1alpha.*;
-
-// Create a client
-var client = Client.newBuilder()
-    .host("aws.s2.dev")
-    .port(443)
-    .bearerToken("your-token")
-    .build();
-
-// List all basins
-var basins = client.account().listBasins("");
-basins.forEach(basin -> 
-    System.out.printf("Basin: %s (state: %s)%n", 
-        basin.getName(), 
-        basin.getState())
-);
-
-// Create a new basin
-var basinConfig = BasinConfig.newBuilder()
-    .setDefaultStreamConfig(
-        StreamConfig.newBuilder()
-            .setStorageClass(StorageClass.STORAGE_CLASS_STANDARD)
-            .build()
-    )
-    .build();
-
-var newBasin = client.account().createBasin("my-basin", basinConfig);
-
-// Switch to the basin
-client.useBasin("my-basin");
-
-// Create a stream
-var streamConfig = StreamConfig.newBuilder()
-    .setStorageClass(StorageClass.STORAGE_CLASS_STANDARD)
-    .build();
-
-client.basin().createStream("my-stream", streamConfig);
-
-// Append a record
-var record = AppendRecord.newBuilder()
-    .setBody(ByteString.copyFromUtf8("Hello, S2!"))
-    .build();
-
-var appendOutput = client.stream().append("my-stream", List.of(record));
-
-// Read records
-var readOutput = client.stream().read("my-stream", 0, null);
-if (readOutput.hasBatch()) {
-    readOutput.getBatch().getRecordsList().forEach(r -> 
-        System.out.printf("Record %d: %s%n", 
-            r.getSeqNum(), 
-            r.getBody().toStringUtf8())
-    );
+    implementation("dev.s2:s2-sdk:0.0.5-SNAPSHOT")
 }
 ```
 
 ## Project Structure
 
-- `s2/` - The main SDK module
-  - `src/main/java/s2/services/` - Core service implementations
-  - `src/main/java/s2/channel/` - Channel management
-  - `src/main/java/s2/auth/` - Authentication handling
-  - `src/main/proto/` - Protocol Buffer definitions
-- `app/` - Example application demonstrating SDK usage
+- `s2/` - The main SDK module.
+- `s2-internal/` - Code and types generated from
+  the [S2 protobuf definitions](https://github.com/s2-streamstore/s2-protos).
+- `app/` - Example application demonstrating SDK usage.
 
 ## Running the Example App
 
 1. Set required environment variables:
+
 ```bash
 export S2_HOST=aws.s2.dev
 export S2_PORT=443
 export S2_TOKEN=your-token
 ```
 
 2. Run the example:
+
 ```bash
 ./gradlew app:run
 ```
 
-## Advanced Usage
-
-### Asynchronous Operations
-
-The SDK supports asynchronous operations through the `AsyncStreamService`:
-
-```java
-// Async append
-client.streamAsync().appendAsync(streamName, records)
-    .thenAccept(output -> 
-        System.out.printf("Append completed: %d to %d%n", 
-            output.getStartSeqNum(), 
-            output.getEndSeqNum())
-    );
-
-// Streaming read session
-client.streamAsync().openReadSession(
-    streamName,
-    0,
-    null,
-    response -> System.out.println("Received records: " + response.getBatch().getRecordsCount()),
-    error -> System.err.println("Error: " + error.getMessage())
-);
-```
-
 ## License
 
-This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the Apache 2.0 License. See the [LICENSE](LICENSE) file for details.

app/build.gradle.kts

@@ -5,8 +5,8 @@
  */
 
 plugins {
-  application
-  java
+    application
+    java
 }
 
 repositories {
@@ -22,14 +22,29 @@ dependencies {
     implementation("io.grpc:grpc-protobuf:$grpcVersion")
     implementation("io.grpc:grpc-stub:$grpcVersion")
     implementation("javax.annotation:javax.annotation-api:1.3.2")
+    implementation("ch.qos.logback:logback-classic:1.2.6")
+    implementation("org.slf4j:slf4j-api:1.7.32")
     testImplementation("org.junit.jupiter:junit-jupiter:5.9.2")
 }
 
-application {
-    // Define the main class for the application.
-    mainClass.set("org.example.app.App")
+val executables = mapOf(
+    "AccountDemo" to "org.example.app.AccountDemo",
+    "BasinDemo" to "org.example.app.BasinDemo",
+    "BufferedReadSessionDemo" to "org.example.app.BufferedReadSessionDemo",
+    "FutureAppendSessionDemo" to "org.example.app.FutureAppendSessionDemo",
+    "ReadSessionDemo" to "org.example.app.ReadSessionDemo",
+)
+
+executables.forEach { name, mainClassName ->
+    tasks.register<JavaExec>("run${name}") {
+        group = "application"
+        description = "Run the $name executable"
+        classpath = sourceSets["main"].runtimeClasspath
+        mainClass.set(mainClassName)
+    }
 }
 
+
 tasks.test {
     useJUnitPlatform()
 }

app/src/main/java/org/example/app/AccountDemo.java

@@ -0,0 +1,49 @@
+package org.example.app;
+
+import java.time.Duration;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import s2.client.Client;
+import s2.config.Config;
+import s2.config.Endpoints;
+import s2.types.Age;
+import s2.types.CreateBasinRequest;
+import s2.types.ListBasinsRequest;
+import s2.types.StorageClass;
+import s2.types.StreamConfig;
+
+public class AccountDemo {
+
+  private static final Logger logger = LoggerFactory.getLogger(AccountDemo.class.getName());
+
+  public static void main(String[] args) throws Exception {
+    var config =
+        Config.newBuilder(System.getenv("S2_AUTH_TOKEN"))
+            .withEndpoints(Endpoints.fromEnvironment())
+            .build();
+
+    try (var client = new Client(config)) {
+
+      var basins = client.listBasins(ListBasinsRequest.newBuilder().build()).get();
+      basins.elems().forEach(basin -> logger.info("basin={}", basin));
+
+      var newBasin =
+          client
+              .createBasin(
+                  CreateBasinRequest.newBuilder()
+                      .withBasin(UUID.randomUUID().toString())
+                      .withDefaultStreamConfig(
+                          StreamConfig.newBuilder()
+                              .withRetentionPolicy(new Age(Duration.ofDays(7)))
+                              .withStorageClass(StorageClass.STANDARD)
+                              .build())
+                      .build())
+              .get();
+      logger.info("newBasin={}", newBasin);
+
+      client.deleteBasin(newBasin.name()).get();
+      logger.info("deleted basin {}", newBasin);
+    }
+  }
+}