CODEWITHSUNDEEP
nestjsgrpc-node
Samion
Samion

Reputation: 95

NestJS - Grpc client: RpcException from server is serialized to an Error instead of RpcException

I've been at this all day and can't seem to find a solution,
please help :)

The service communication works, the issue is with the error handling...

Scenario:

Service-A is invoked via HTTP. (probably not relevant but just in case)
Service-A calls Service-B via RPC.
Service-B throws an error.
an exception filter on Service-B's controller catches that error and translates it to a RpcException and returns that to to Service-A.
Service-A receives an Error not a RpcExcpetion.

The error is caught in the global error handler as it is not recognized as a RpcException
(would have been caught in Service-B's RpcExceptionFilter...)

Some code:

Service-A:

client configuration
    @Module({
        imports: [...],
        controllers: [...],
        providers: [{
            provide: 'somePackage',
            useFactory(configService: ConfigService) {
                return ClientProxyFactory.create(
                    {
                        transport: Transport.GRPC,
                        options: {
                            url: 'localhost:5000',
                            package: 'somePackage',
                            protoPath: 'pathToProto',
                        },
                    }
                );
            },
            inject: [ConfigService],
        }]
    })
client service injection and init
    export class ServiceA implements OnModuleInit {
    
        private someService: SomeServiceClient;
    
        onModuleInit(): any {
            this.someService = this.client.getService<SomeServiceClient>('SomeService');
        }
    
        constructor(@Inject(somePackage) private client: ClientGrpc)
    }
client method call

await lastValueFrom(this.someService.workWork(workWorkRequest));

Service-B:

error conversion (ExceptionFilter)
catch(exception: RpcException){
        const rpcException: RpcException = someConversionFunction(exception);
        return throwError(() => rpcException.getError());
    }

some logging outputs:

this is what thrown on service-a:
[error][2022-05-30T18:58:13.132Z]-[App/Main] - 9 FAILED_PRECONDITION: Some Service-B error message if i try catch the call and log the error:

Error: 9 FAILED_PRECONDITION: Some Service-B error message
    at Object.callErrorFromStatus (@grpc/grpc-js/src/call.ts:81:24)
    at Object.onReceiveStatus (@grpc/grpc-js/src/client.ts:343:36)
    at Object.onReceiveStatus (@grpc/grpc-js/src/client-interceptors.ts:462:34)
    at Object.onReceiveStatus (@grpc/grpc-js/src/client-interceptors.ts:424:48)
    at @grpc/grpc-js/src/call-stream.ts:323:24
    at processTicksAndRejections (node:internal/process/task_queues:78:11) {
    code: 9,
    details: 'Some Service-B error message',
    metadata: Metadata { internalRepr: Map(0) {}, options: {} }
}

what i expect is basically the same, just as a RpcError:
RpcException [Error]: Some Service-B error message

I've tried to minimize the code as much as possible...
Any input is welcome...
Thanks!

Upvotes: 0

Views: 1552

Answers (1)

Samion
Samion

Reputation: 95

If anyone stumbles across this,
It is now possible to add an error serializer when creating the ClientProxy like so:

class ErrorHandlingProxy extends ClientGrpcProxy {
  serializeError(err) {
    return new RpcException(err);
  }
}

@Module({
  providers: [
    {
      provide: 'HERO_PACKAGE',
      useFactory() {
        return new ErrorHandlingProxy(grpcClientOptions.options);
      },
    },
  ],
  controllers: [HeroController],
})
export class HeroModule {}

More details in this issue

Upvotes: 2

Related Questions