chore: prepare for release

Author: francescovallone

.website/microservices/grpc.md

@@ -80,15 +80,9 @@ class GreeterService extends GreeterServiceBase {
 }
 ```
 
-::: info
-Right now the methods implementation won't affect the result of the gRPC calls done through Serinus, since the actual handling of the calls will be done by the controllers. However, it's a good practice to implement the methods in case you want to use the service outside of Serinus.
-
-Also we are working on a feature that will also call the service methods from the controllers, so stay tuned for that!
-:::
-
 ### Configure the gRPC transport
 
-To instantiate a gRPC microservice application, you can use the `GrpcTransport` transport layer from the `serinus_microservices` package. You will need to provide the list of gRPC services to the `GrpcOptions`.
+To instantiate a gRPC microservice application, you can use the `GrpcTransport` transport layer from the `serinus_microservices` package.
 
 ```dart
 final microservice = await serinus.createMicroservice(
@@ -97,15 +91,28 @@ final microservice = await serinus.createMicroservice(
     GrpcOptions(
       port: 50051,
       host: InternetAddress.loopbackIPv4,
-      services: [
-        GreeterService(),
-      ],
     ),
   ),
 );
 ```
 
-As you can see we are passing the concrete implementation of the `GreeterService` to the `services` option of the `GrpcOptions` instead of the generated `GreeterServiceBase` abstract class.
+We also need to register the `GreeterService` in the `AppModule` so that it can be injected into the gRPC controller:
+
+```dart
+class GreeterController extends GrpcServiceController {
+  GreeterController(): super(service: GreeterService());
+}
+
+class AppModule extends Module {
+  
+  AppModule(): super(
+    controllers: [GreeterController()],
+  );
+
+}
+```
+
+And that's it! From this moment on the gRPC service will take care of handling incoming gRPC requests and routing them to the appropriate controller methods based on the service and method names defined in the proto file. Also since you have tapped into the full power of the Serinus framework, you can use all the features of Serinus in your gRPC controllers, such as dependency injection, hooks, filters and more.
 
 ## Options
 
@@ -119,112 +126,3 @@ The `GrpcOptions` class allows you to configure various settings for the gRPC tr
 | codecRegistry | An optional codec registry for custom serialization and deserialization of messages. |
 | keepAliveOptions | Options for configuring keep-alive behavior for the gRPC server. |
 | security | An optional security configuration for the gRPC server, such as TLS settings. |
-
-## gRPC Controller
-
-Since Controllers in Serinus are transport-agnostic, to create a gRPC controller you need to augment your own controller with the `GrpcController` mixin from the `serinus_microservices` package.
-
-```dart
-import 'package:serinus_microservices/serinus_microservices.dart';
-
-class MyGrpcController extends Controller with GrpcController {
-  
-  MyGrpcController() : super('/my_grpc_controller') {
-    grpc<HelloRequest, HelloReply>(
-      GrpcRoute(GreeterService, 'SayHello'),
-      (call, request, context) async {
-        final reply = HelloReply()..message = context.use<GreeterProvider>().getGreeting(request.name);
-        return reply;
-      }
-    );
-  }
-
-}
-```
-
-As you can see to define a gRPC route you need to use the `grpc` method provided by the `GrpcController` mixin. This method takes a `GrpcRoute` object that specifies the service and method names, and a handler function that will be called when the route is invoked.
-
-The GrpcRoute constructor takes two parameters:
-
-- The gRPC service class (the concrete implementation, **not** the abstract class).
-- The name of the gRPC method as defined in the proto file.
-
-The reason behind the need to specify the concrete implementation of the service is that Serinus uses it as the key to identify the service and route the incoming requests to the correct controller.
-
-> [!IMPORTANT]
-> Make sure to use the concrete implementation of the gRPC service when defining the `GrpcRoute`, otherwise Serinus won't be able to route the requests correctly and you will get an error at runtime.
-
-In this example, we defined a unary gRPC method `SayHello` in the `GreeterService`. The handler function takes three parameters: the `ServiceCall` object, the request message, and the `GrpcRouteContext` object.
-
-## gRPC Streaming
-
-Serinus also supports gRPC streaming methods.
-
-### Define a streaming gRPC method
-
-Let's define a server streaming method in our `Greeter` service:
-
-```proto
-// The greeting service definition.
-service Greeter {
-  // Sends a greeting
-  rpc SayHello (HelloRequest) returns (HelloReply) {}
-  rpc LotsOfHellos (stream HelloRequest) returns (stream HelloReply) {}
-}
-
-// The request message containing the user's name.
-message HelloRequest {
-  string name = 1;
-}
-
-// The response message containing the greetings
-message HelloReply {
-  string message = 1;
-}
-```
-
-As before, you need to regenerate the gRPC code after modifying the proto file.
-
-```console
-protoc --dart_out=grpc:lib/generated -Iprotos protos/greeter.proto
-```
-
-### Implement the streaming method
-
-Now we need to define the method in the concrete implementation of the `GreeterService`:
-
-```dart
-class GreeterService extends GreeterServiceBase {
-  @override
-  Stream<HelloReply> lotsOfHellos(ServiceCall call, Stream<HelloRequest> requestStream) async* {
-    await for (final request in requestStream) {
-      final reply = HelloReply()..message = 'Hello, ${request.name}!';
-      yield reply;
-    }
-  }
-
-  @override
-  Future<HelloReply> sayHello(ServiceCall call, HelloRequest request) async {
-    final reply = HelloReply()..message = 'Hello, ${request.name}!';
-    return reply;
-  }
-}
-```
-
-### Define the streaming route
-
-And now we can define the streaming route in our gRPC controller using the `grpcStream` method provided by the `GrpcController` mixin.
-
-```dart
-grpcStream<HelloRequest, HelloReply>(
-  GrpcRoute(GreeterService, 'StreamHellos'),
-  (call, requestStream, context) async* {
-    await for (final request in requestStream) {
-      final reply = HelloReply()..message = context.use<GreeterProvider>().getGreeting(request.name);
-      yield reply;
-    }
-  }
-);
-```
-
-And that's it! You have successfully created a gRPC microservice with Serinus that supports both unary and streaming methods.

packages/serinus/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 2.1.6
+
+**Released on:** 12-03-2026
+
+### Fixes
+
+- Reduce overhead of the request handling by using weak eTags and by using the request relative uri instead of the absolute uri.
+
 ## 2.1.5
 
 **Released on:** 07-03-2026

packages/serinus/pubspec.yaml

@@ -4,7 +4,7 @@ description: Serinus is a framework written in Dart
 documentation: https://serinus.app
 homepage: https://serinus.app
 repository: https://github.com/francescovallone/serinus
-version: 2.1.5
+version: 2.1.6
 funding:
   - https://github.com/sponsors/francescovallone
 topics:

packages/serinus_microservices/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.0.0
+
+- Stablilized API and released the first stable version of the microservices package.
+
 ## 0.1.1
 
 - chore: update dependencies.

packages/serinus_microservices/bin/serinus_microservices.dart

@@ -16,7 +16,8 @@ class TestModule extends Module {
 }
 
 class Test2Module extends Module {
-  Test2Module() : super(imports: [TestModule()], controllers: [Test2Controller()]);
+  Test2Module()
+    : super(imports: [TestModule()], controllers: [Test2Controller()]);
 }
 
 class Test2Controller extends Controller {
@@ -43,7 +44,11 @@ class AppController extends Controller with RpcController {
 }
 
 class AppModule extends Module {
-  AppModule() : super(imports: [Test2Module(), TestModule()], controllers: [AppController()]);
+  AppModule()
+    : super(
+        imports: [Test2Module(), TestModule()],
+        controllers: [AppController()],
+      );
 }
 
 void main(List<String> arguments) async {

packages/serinus_microservices/lib/transporters/grpc/grpc_client.dart

@@ -75,7 +75,11 @@ class GrpcClient extends TransportClient<GrpcClientOptions> {
   }
 
   @override
-  Future<ResponsePacket?> send({required String pattern, required String id, Uint8List? payload}) {
+  Future<ResponsePacket?> send({
+    required String pattern,
+    required String id,
+    Uint8List? payload,
+  }) {
     throw UnimplementedError('send is not implemented for GrpcClient.');
   }
 }

packages/serinus_microservices/lib/transporters/grpc/grpc_controller.dart

@@ -1,124 +1,15 @@
 import 'package:grpc/grpc.dart';
-import 'package:protobuf/protobuf.dart';
 import 'package:serinus/serinus.dart';
 
 /// The [GrpcServiceController] allows defining gRPC services as Serinus Controllers.
-/// 
+///
 /// It extends the base [Controller] class and includes a reference to the gRPC [Service] it represents. This controller can be used to group related gRPC methods together, making it easier to manage and organize your gRPC services within the Serinus framework.
 class GrpcServiceController extends Controller {
-
   /// The [service] property contains the gRPC service definition that this controller represents.
   final Service service;
 
   /// Creates a gRPC service controller.
   GrpcServiceController({
     required this.service,
-  }): super(service.$name);
-}
-
-/// The [GrpcRoute] class is the gRPC
-class GrpcRoute extends Route {
-  /// The [serviceName] property contains the name of the gRPC service.
-  final Type serviceName;
-
-  /// The [methodName] property contains the name of the gRPC method.
-  final String methodName;
-
-  /// Creates a gRPC route.
-  GrpcRoute(this.serviceName, this.methodName) : super(path: '$serviceName.$methodName', method: HttpMethod.get);
-}
-
-/// The [GrpcHandler] typedef is the gRPC handler function.
-class GrpcUnaryHandler<Req extends GeneratedMessage, Res extends GeneratedMessage> {
-  /// The handler function.
-  final Future<Res> Function(ServiceCall call, Req request, RpcContext context) _handler;
-
-  /// Creates a gRPC unary handler.
-  GrpcUnaryHandler(this._handler);
-
-  /// Calls the handler function.
-  Future<Res> call(ServiceCall call, Req request, RpcContext context) {
-    return _handler(call, request, context);
-  }
-}
-
-/// The [GrpcStreamHandler] typedef is the gRPC stream handler function.
-class GrpcStreamHandler<Req extends GeneratedMessage, Res extends GeneratedMessage> {
-  /// The handler function.
-  final Stream<Res> Function(ServiceCall call, Stream<Req> requests, RpcContext context) _handler;
-
-  /// Creates a gRPC stream handler.
-  GrpcStreamHandler(this._handler);
-
-  /// Calls the handler function.
-  Stream<Res> call(ServiceCall call, Stream<Req> requests, RpcContext context) {
-    return _handler(call, requests, context);
-  }
-}
-
-/// The [GrpcRouteSpec] class is used to define a gRPC route handler specification.
-abstract class GrpcRouteSpec<T, Req, Res> extends RouteHandlerSpec<T> {
-  @override
-  T get handler => super.handler;
-
-  /// The [GrpcRouteSpec] constructor is used to create a new instance of the [GrpcRouteSpec] class.
-  GrpcRouteSpec(super.route, super.handler);
-}
-
-/// The [GrpcRouteHandlerSpec] class is the gRPC route handler specification.
-class GrpcRouteHandlerSpec<Req extends GeneratedMessage, Res extends GeneratedMessage>
-    extends GrpcRouteSpec<GrpcUnaryHandler, Req, Res> {
-  /// Creates a gRPC route handler specification.
-  GrpcRouteHandlerSpec(
-    GrpcRoute route,
-    Future<Res> Function(ServiceCall call, Req request, RpcContext context) handler,
-  ) : super(route, GrpcUnaryHandler<Req, Res>(handler));
-}
-
-/// The [GrpcStreamRouteHandlerSpec] class is the gRPC streaming route handler specification.
-class GrpcStreamRouteHandlerSpec<Req extends GeneratedMessage, Res extends GeneratedMessage>
-    extends GrpcRouteSpec<GrpcStreamHandler, Req, Res> {
-  /// Creates a gRPC stream route handler specification.
-  GrpcStreamRouteHandlerSpec(
-    GrpcRoute route,
-    Stream<Res> Function(ServiceCall call, Stream<Req> requests, RpcContext context) handler,
-  ) : super(route, GrpcStreamHandler<Req, Res>(handler));
-}
-
-/// The [GrpcController] mixin is used to add gRPC routes to a controller.
-mixin GrpcController on Controller {
-  /// The [grpcRoutes] property contains the gRPC routes of the controller.
-  final Map<String, GrpcRouteSpec> grpcRoutes = {};
-
-  /// Registers a gRPC route with the controller.
-  void grpc<Req extends GeneratedMessage, Res extends GeneratedMessage>(
-    GrpcRoute route,
-    Future<Res> Function(ServiceCall call, Req request, RpcContext context) handler,
-  ) {
-    if (grpcRoutes.containsKey(route.path)) {
-      throw StateError(
-        'A gRPC method with name "${route.path}" is already registered in the controller.',
-      );
-    }
-    grpcRoutes[route.path] = GrpcRouteHandlerSpec<Req, Res>(
-      route,
-      handler,
-    );
-  }
-
-  /// Registers a gRPC streaming route with the controller.
-  void grpcStream<Req extends GeneratedMessage, Res extends GeneratedMessage>(
-    GrpcRoute route,
-    Stream<Res> Function(ServiceCall call, Stream<Req> requests, RpcContext context) handler,
-  ) {
-    if (grpcRoutes.containsKey(route.path)) {
-      throw StateError(
-        'A gRPC streaming method with name "${route.path}" is already registered in the controller.',
-      );
-    }
-    grpcRoutes[route.path] = GrpcStreamRouteHandlerSpec<Req, Res>(
-      route,
-      handler,
-    );
-  }
+  }) : super(service.$name);
 }