Flatbuffer gRPC streaming definitions (bidi, server, client...) - flatbuffers

Question

I'm trying to implement a Flatbuffer gRPC server and was original confused by the streaming: "server" definition. After much digging and frustration because of the lack of documentation on the topic I did manage to figure out that there are a few streaming types that can be declared:
rpc_service MonsterStorage {
Store(Monster):Stat (streaming: "none");
Retrieve(Stat):Monster (streaming: "server", idempotent);
GetMaxHitPoint(Monster):Stat (streaming: "client");
GetMinMaxHitPoints(Monster):Stat (streaming: "bidi");
}
Now I'm even more curious. It seems that bidi was the one that I needed, but what do none, server and client mean? What does idempotent do to the stream?
Is this actually documented somewhere and I'm just terrible at searching? lol.

Answer 1

gRPC's introduction to the four types of streaming is https://www.grpc.io/docs/languages/cpp/basics/#defining-the-service
Translating that example into flatbuffers yields:
rpc_service RouteGuide {
// A simple RPC where the client sends a request to the server using the stub
// and waits for a response to come back, just like a normal function call.
/// Obtains the feature at a given position.
GetFeature(Point): Feature (streaming: "none");
// A server-side streaming RPC where the client sends a request to the server
// and gets a stream to read a sequence of messages back. The client reads
// from the returned stream until there are no more messages.
/// Obtains the Features available within the given Rectangle. Results are
/// streamed rather than returned at once (e.g. in a response message with a
/// repeated field), as the rectangle may cover a large area and contain a
/// huge number of features.
ListFeatures(Rectangle): Feature (streaming: "server");
// A client-side streaming RPC where the client writes a sequence of
// messages and sends them to the server, again using a provided stream.
// Once the client has finished writing the messages, it waits for the server to
// read them all and return its response.
/// Accepts a stream of Points on a route being traversed, returning a
/// RouteSummary when traversal is completed.
RecordRoute(Point): RouteSummary (streaming: "client");
// A bidirectional streaming RPC where both sides send a sequence of
// messages using a read-write stream. The two streams operate
// independently, so clients and servers can read and write in whatever order
// they like: for example, the server could wait to receive all the client
// messages before writing its responses, or it could alternately read a
// message then write a message, or some other combination of reads and
// writes. The order of messages in each stream is preserved.
/// Accepts a stream of RouteNotes sent while a route is being traversed,
/// while receiving other RouteNotes (e.g. from other users).
RouteChat(RouteNote): RouteNote (streaming: "bidi");
}