refactor: api removed broadcast, becasue it was moved to typed MessageChannel

Author: objz

README.md

@@ -103,22 +103,49 @@ CB has a public API module for other plugins to interact with the bridge network
 ```java
 CommandBridgeAPI api = CommandBridgeProvider.get();
 
-// send a command as console to a backend
-CommandChannel commands = api.channel(Channels.COMMAND);
-commands.console(Platform.BACKEND.target("survival-1"), "say hello");
+// get a typed message channel
+MessageChannel<CommandPayload> commands = api.channel(Channels.COMMAND);
 
-// listen for incoming messages
-Subscription sub = commands.listen((ctx, payload) -> { /* ... */ });
+// send a command as console to a specific backend
+commands.send(Platform.BACKEND.target("survival-1"), CommandPayload.console("say hello"));
 
-// server events
-api.onServerConnected(server -> { /* ... */ });
-api.onServerDisconnected(server -> { /* ... */ });
+// send a command as a player
+commands.send(Platform.BACKEND.target("survival-1"), CommandPayload.player("spawn", playerUuid));
 
-// find a player across the network
-api.playerLocator().ifPresent(locator -> locator.locate(playerUuid));
+// broadcast a command to all connected servers
+commands.broadcast(CommandPayload.console("say maintenance in 5 minutes"));
 
-// broadcast to all servers
-api.broadcast(commands, CommandPayload.console("say maintenance in 5 minutes"));
+// request-response (waits for the target to reply)
+commands.request(Platform.BACKEND.target("survival-1"), CommandPayload.console("list"))
+        .thenAccept(response -> { /* handle response */ });
+
+// listen for incoming messages on this channel
+Subscription sub = commands.listen((ctx, payload) -> {
+    Platform.ServerTarget from = ctx.from();
+    String command = payload.command();
+});
+sub.cancel(); // unsubscribe when done
+
+// server lifecycle events
+api.onServerConnected(server -> { /* server joined the network */ });
+api.onServerDisconnected(server -> { /* server left the network */ });
+
+// connection state monitoring
+api.onConnectionStateChanged(state -> {
+    if (state.canSend()) { /* ready to send messages */ }
+});
+
+// current server identity and state
+Platform.ServerTarget self = api.server();
+ConnectionState state = api.connectionState();
+
+// list all connected servers (available on velocity)
+api.connectedServers().ifPresent(servers -> { /* Set<String> of server IDs */ });
+
+// find which server a player is on (available on velocity)
+api.playerLocator().ifPresent(locator ->
+        locator.locate(playerUuid).ifPresent(server -> { /* player is on this server */ })
+);
 ```
 
 ---

api/src/main/java/dev/objz/commandbridge/api/CommandBridgeAPI.java

@@ -11,7 +11,6 @@
 
 import java.util.Optional;
 import java.util.Set;
-import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 
 /** Main entry point for interacting with the CommandBridge network. */
@@ -27,15 +26,6 @@ public interface CommandBridgeAPI {
      */
     <T extends ChannelPayload, C extends MessageChannel<T>> C channel(ChannelType<T, C> type);
 
-    /**
-     * Broadcasts a payload to all connected servers on a specific channel.
-     *
-     * @param channel the channel to broadcast on
-     * @param payload the data to send
-     * @return a future that completes when the broadcast is dispatched
-     */
-    <P extends ChannelPayload> CompletableFuture<Void> broadcast(MessageChannel<P> channel, P payload);
-
     /** @return the identity of the current server */
     Platform.ServerTarget server();
 

api/src/main/java/dev/objz/commandbridge/api/channel/MessageChannel.java

@@ -23,6 +23,14 @@ public interface MessageChannel<P extends ChannelPayload> {
      */
     CompletableFuture<Void> send(Platform.ServerTarget target, P payload);
 
+    /**
+     * Broadcasts a payload to all connected servers.
+     *
+     * @param payload the data to send
+     * @return a future that completes when the broadcast is dispatched
+     */
+    CompletableFuture<Void> broadcast(P payload);
+
     /**
      * Sends a request to a target server and waits for a response.
      *

backends/src/main/java/dev/objz/commandbridge/backends/api/BackendCommandBridgeImpl.java

@@ -83,13 +83,6 @@ public <T extends ChannelPayload, C extends MessageChannel<T>> C channel(Channel
         return typeCast(channel);
     }
 
-    @Override
-    public <P extends ChannelPayload> CompletableFuture<Void> broadcast(MessageChannel<P> channel, P payload) {
-        Objects.requireNonNull(channel);
-        Objects.requireNonNull(payload);
-        return channel.send(Platform.BACKEND.target("*"), payload);
-    }
-
     @Override
     public Platform.ServerTarget server() {
         return Platform.BACKEND.target(localServerId());

core/src/main/java/dev/objz/commandbridge/net/channel/PluginMessageChannel.java

@@ -53,6 +53,12 @@ public CompletableFuture<Void> send(Platform.ServerTarget target, P payload) {
         return sendTransport.send(target, toPluginMessage(payload, false));
     }
 
+    @Override
+    public CompletableFuture<Void> broadcast(P payload) {
+        Objects.requireNonNull(payload);
+        return sendTransport.send(Platform.BACKEND.target("*"), toPluginMessage(payload, false));
+    }
+
     @Override
     public CompletableFuture<P> request(Platform.ServerTarget target, P payload) {
         return request(target, payload, Duration.ofSeconds(15));

velocity/src/main/java/dev/objz/commandbridge/velocity/api/VelocityCommandBridgeImpl.java

@@ -71,20 +71,6 @@ public <T extends ChannelPayload, C extends MessageChannel<T>> C channel(Channel
         return typeCast(channel);
     }
 
-    @Override
-    public <P extends ChannelPayload> CompletableFuture<Void> broadcast(MessageChannel<P> channel, P payload) {
-        Objects.requireNonNull(channel);
-        Objects.requireNonNull(payload);
-        List<CompletableFuture<Void>> futures = new ArrayList<>();
-        for (ClientSession session : sessions) {
-            if (!isRoutable(session)) {
-                continue;
-            }
-            futures.add(channel.send(toPlatform(session.location()).target(session.id()), payload));
-        }
-        return CompletableFuture.allOf(futures.toArray(CompletableFuture[]::new));
-    }
-
     @Override
     public Platform.ServerTarget server() {
         return Platform.VELOCITY.target(serverId);
@@ -229,6 +215,10 @@ private <P extends ChannelPayload> Subscription registerListener(ChannelType<P,
     }
 
     private CompletableFuture<Void> sendPluginMessage(Platform.ServerTarget target, PluginMessage payload) {
+        if ("*".equals(target.id())) {
+            return broadcastPluginMessage(payload);
+        }
+
         if (isLocalVelocity(target)) {
             Envelope local = Envelope.make(MessageType.PLUGIN_MESSAGE, serverId, serverId,
                     Envelope.MAPPER.valueToTree(payload));
@@ -247,6 +237,19 @@ private CompletableFuture<Void> sendPluginMessage(Platform.ServerTarget target,
         return endpointServer.send(session.get().endpoint(), env).dispatch();
     }
 
+    private CompletableFuture<Void> broadcastPluginMessage(PluginMessage payload) {
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (ClientSession session : sessions) {
+            if (!isRoutable(session)) {
+                continue;
+            }
+            Envelope env = Envelope.make(MessageType.PLUGIN_MESSAGE, serverId, session.id(),
+                    Envelope.MAPPER.valueToTree(payload));
+            futures.add(endpointServer.send(session.endpoint(), env).dispatch());
+        }
+        return CompletableFuture.allOf(futures.toArray(CompletableFuture[]::new));
+    }
+
     private CompletableFuture<PluginMessage> requestPluginMessage(Platform.ServerTarget target,
             PluginMessage payload,
             Duration timeout) {