feat: ability to set connect-rpc protocol

Author: strantalis

sdk/src/main/java/io/opentdf/platform/sdk/ProtocolType.java

@@ -0,0 +1,46 @@
+package io.opentdf.platform.sdk;
+
+import com.connectrpc.protocols.NetworkProtocol;
+
+/**
+ * Enumeration of supported network protocols for SDK communication.
+ * 
+ * This enum provides a mapping between SDK protocol types and the underlying
+ * Connect-RPC NetworkProtocol values, allowing flexible configuration of the
+ * communication protocol used for platform services.
+ */
+public enum ProtocolType {
+    /**
+     * Connect's native protocol - HTTP-based with support for HTTP/1.1, HTTP/2, and HTTP/3.
+     * Supports both JSON and binary Protobuf encoding with streaming capabilities.
+     * This is the recommended default for new applications.
+     */
+    CONNECT(NetworkProtocol.CONNECT),
+    
+    /**
+     * Standard gRPC protocol - requires HTTP/2 and uses binary Protobuf encoding.
+     * Provides full gRPC compatibility including streaming, trailers, and error details.
+     */
+    GRPC(NetworkProtocol.GRPC),
+    
+    /**
+     * gRPC-Web protocol - designed for web browsers, works over HTTP/1.1 and HTTP/2.
+     * Eliminates the need for a translating proxy like Envoy.
+     */
+    GRPC_WEB(NetworkProtocol.GRPC_WEB);
+    
+    private final NetworkProtocol networkProtocol;
+    
+    ProtocolType(NetworkProtocol networkProtocol) {
+        this.networkProtocol = networkProtocol;
+    }
+    
+    /**
+     * Get the underlying Connect-RPC NetworkProtocol value.
+     * 
+     * @return the NetworkProtocol corresponding to this ProtocolType
+     */
+    public NetworkProtocol getNetworkProtocol() {
+        return networkProtocol;
+    }
+}

sdk/src/main/java/io/opentdf/platform/sdk/SDKBuilder.java

@@ -65,6 +65,7 @@ public class SDKBuilder {
     private Boolean usePlainText;
     private SSLFactory sslFactory;
     private AuthorizationGrant authzGrant;
+    private ProtocolType protocolType = ProtocolType.CONNECT;
 
     private static final Logger logger = LoggerFactory.getLogger(SDKBuilder.class);
 
@@ -160,6 +161,18 @@ public SDKBuilder useInsecurePlaintextConnection(Boolean usePlainText) {
         return this;
     }
 
+    /**
+     * Set the network protocol to use for communication with platform services.
+     * 
+     * @param protocolType the protocol type to use (CONNECT, GRPC, or GRPC_WEB)
+     * @return this builder instance for method chaining
+     * @see ProtocolType for available protocol options
+     */
+    public SDKBuilder protocol(ProtocolType protocolType) {
+        this.protocolType = protocolType;
+        return this;
+    }
+
     private Interceptor getAuthInterceptor(RSAKey rsaKey) {
         if (platformEndpoint == null) {
             throw new SDKException("cannot build an SDK without specifying the platform endpoint");
@@ -329,7 +342,7 @@ private ProtocolClient getProtocolClient(String endpoint, OkHttpClient httpClien
         var protocolClientConfig = new ProtocolClientConfig(
                 endpoint,
                 new GoogleJavaProtobufStrategy(),
-                NetworkProtocol.GRPC,
+                protocolType.getNetworkProtocol(),
                 null,
                 GETConfiguration.Enabled.INSTANCE,
                 authInterceptor == null ? Collections.emptyList() : List.of(ignoredConfig -> authInterceptor)

sdk/src/test/java/io/opentdf/platform/sdk/KASClientTest.java

@@ -45,7 +45,7 @@ public class KASClientTest {
     BiFunction<OkHttpClient, String, ProtocolClient> aclientFactory = (OkHttpClient client, String endpoint) -> {
         return new ProtocolClient(
                 new ConnectOkHttpClient(httpClient),
-                new ProtocolClientConfig(endpoint, new GoogleJavaProtobufStrategy(), NetworkProtocol.GRPC, null, GETConfiguration.Enabled.INSTANCE)
+                new ProtocolClientConfig(endpoint, new GoogleJavaProtobufStrategy(), ProtocolType.GRPC.getNetworkProtocol(), null, GETConfiguration.Enabled.INSTANCE)
         );
     };
 

sdk/src/test/java/io/opentdf/platform/sdk/SDKBuilderTest.java

@@ -412,6 +412,58 @@ public void getNamespace(GetNamespaceRequest request,
         }
     }
 
+    @Test
+    void testProtocolConfiguration() {
+        // Test that protocol configuration works and defaults to CONNECT
+        
+        // Test default protocol setting
+        SDKBuilder.ServicesAndInternals services1 = SDKBuilder.newBuilder()
+                .clientSecret("user", "password")
+                .platformEndpoint("http://localhost:8080")
+                .useInsecurePlaintextConnection(true)
+                .buildServices();
+        
+        // Test explicit GRPC protocol setting
+        SDKBuilder.ServicesAndInternals services2 = SDKBuilder.newBuilder()
+                .clientSecret("user", "password")
+                .platformEndpoint("http://localhost:8080")
+                .useInsecurePlaintextConnection(true)
+                .protocol(ProtocolType.GRPC)
+                .buildServices();
+        
+        // Test GRPC_WEB protocol setting
+        SDKBuilder.ServicesAndInternals services3 = SDKBuilder.newBuilder()
+                .clientSecret("user", "password")
+                .platformEndpoint("http://localhost:8080")
+                .useInsecurePlaintextConnection(true)
+                .protocol(ProtocolType.GRPC_WEB)
+                .buildServices();
+        
+        // Test CONNECT protocol setting
+        SDKBuilder.ServicesAndInternals services4 = SDKBuilder.newBuilder()
+                .clientSecret("user", "password")
+                .platformEndpoint("http://localhost:8080")
+                .useInsecurePlaintextConnection(true)
+                .protocol(ProtocolType.CONNECT)
+                .buildServices();
+        
+        // Verify that all configurations create services successfully
+        assertThat(services1.services).isNotNull();
+        assertThat(services2.services).isNotNull();
+        assertThat(services3.services).isNotNull();
+        assertThat(services4.services).isNotNull();
+        
+        // Clean up
+        try {
+            services1.services.close();
+            services2.services.close();
+            services3.services.close();
+            services4.services.close();
+        } catch (Exception ignored) {
+            // ignore cleanup errors in test
+        }
+    }
+
     public static int getRandomPort() throws IOException {
         int randomPort;
         try (ServerSocket socket = new ServerSocket(0)) {