handleMessage method

@override Future<ResponsePacket?> handleMessage(MessagePacket packet, TransportAdapter<dynamic, TransportOptions> adapter)

Handle an incoming message packet and return a response packet if applicable.

Implementation

@override
Future<ResponsePacket?> handleMessage(
  MessagePacket packet,
  TransportAdapter adapter,
) async {
  final routeContext = resolvedMessageRoutes[packet.pattern];
  if (routeContext == null) {
    throw GrpcError.notFound(
      'No message route found for pattern "${packet.pattern}"',
    );
  }
  try {
    final executionContext = ExecutionContext(
      HostType.rpc,
      routeContext.providers,
      {
        for (final hook in routeContext.hooks.reqHooks) hook.runtimeType: hook,
      },
      RpcArgumentsHost(packet),
    );
    for (final pipe in routeContext.pipes) {
      await pipe.transform(executionContext);
    }
    final grpcPayload = packet.payload as GrpcPayload;
    final call = grpcPayload.call;
    final request = await grpcPayload.getRequest();
    final result = await routeContext.handler(
      call,
      request,
      executionContext.switchToRpc(),
    );
    if (packet.id != null) {
      return ResponsePacket(
        pattern: packet.pattern,
        id: packet.id,
        payload: result,
      );
    }
  } on RpcException catch (e) {
    for (final filter in routeContext.exceptionFilters) {
      if (filter.catchTargets.contains(e.runtimeType) || filter.catchTargets.isEmpty) {
        final executionContext = ExecutionContext(
          HostType.rpc,
          routeContext.providers,
          {
            for (final hook in routeContext.hooks.reqHooks) hook.runtimeType: hook,
          },
          RpcArgumentsHost(packet),
        );
        await filter.onException(executionContext, e);
        break;
      }
      return ResponsePacket(
        pattern: packet.pattern,
        id: packet.id,
        isError: true,
        payload: {'error': e.message},
      );
    }
  }
  return null;
}