A modern programming language that makes developers happier.

kotlinlang

set the channel description: Discussion of the pbandk Kotlin Multiplatform protocol buffer library: <https://github.com/streem/pbandk>

Does "anyone" has any example of using pbandk with gRPC? I am trying to put it together with grpc-java.

Hi <@U01CU4XA4UB> :wave: Sorry, I didn’t have my Slack notifications setup correctly and missed your question until now. I’ve only seen one mention of someone using gRPC together with pbandk: <https://github.com/streem/pbandk/pull/163#issuecomment-957314961>. In that thread <@U01JFBFVBEF> mentioned that they were considering open-sourcing their pbandk &lt;-&gt; gRPC implementation but I don’t think they’ve done so yet.

Hi, so I am the second person using pbandk with gRPC. I am interfacing with platform specific gRPC implementations for JVM and node.js.

JVM:
```open class GrpcServiceServer&lt;Service&gt;(
    private val serviceName: String,
    private val service: Service,
    private val methods: List&lt;GrpcServiceMethod&lt;Service, *, *&gt;&gt;
) : AbstractCoroutineServerImpl() {
    override fun bindService(): ServerServiceDefinition {
        val builder = ServerServiceDefinition.builder(serviceName)
        methods.forEach {
            builder.addMethod(it.serverMethodDefinition(serviceName, service))
        }
        return builder.build()
    }
}

class GrpcServiceMethod&lt;Service, Request : Message?, Response : Message?&gt;(
    val name: String,
    val method: suspend Service.(request: Request) -&gt; Response,
    val requestDecoder: (InputStream) -&gt; Request,
    val responseDecoder: (InputStream) -&gt; Response
) {
    private fun methodDescriptor(serviceName: String): MethodDescriptor&lt;Request, Response&gt; {
        return MethodDescriptor.newBuilder&lt;Request, Response&gt;()
            .setType(MethodDescriptor.MethodType.UNARY)
            .setFullMethodName("$serviceName/$name")
            .setRequestMarshaller(object : MethodDescriptor.Marshaller&lt;Request&gt; {
                override fun stream(value: Request): InputStream {
                    return ByteArrayInputStream(value!!.encodeToByteArray())
                }

                override fun parse(stream: InputStream): Request {
                    return requestDecoder(stream)
                }

            })
            .setResponseMarshaller(object : MethodDescriptor.Marshaller&lt;Response&gt; {
                override fun stream(value: Response): InputStream {
                    return ByteArrayInputStream(value!!.encodeToByteArray())
                }

                override fun parse(stream: InputStream): Response {
                    return responseDecoder(stream)
                }

            })
            .build()
    }

    internal fun serverMethodDefinition(
        serviceName: String,
        service: Service
    ): ServerMethodDefinition&lt;Request, Response&gt; {
        return ServerCalls.unaryServerMethodDefinition(
            EmptyCoroutineContext,
            methodDescriptor(serviceName)
        ) { request: Request -&gt;
            withContext(coroutineContext + PrincipalContext(JwtCallCredentials.KEY.get().principal)) {
                try {
                    service.method(request)
                } catch (e: UnauthorizedException) {
                    throw StatusRuntimeException(Status.UNAUTHENTICATED)
                }
            }
        }
    }
}```
```class GrpcProfileServer(
    private val profileService: ProfileService
) : GrpcServiceServer&lt;ProfileService&gt;(
    "pl.mensa.skillmatrix.schema.service.ProfileService",
    profileService,
    listOf(
        GrpcServiceMethod(
            "Get",
            { userId -&gt; profileService.get(userId.toModel())?.toSchema() },
            UserId.Companion::decodeFromStream,
            Profile.Companion::decodeFromStream
        )
    )
)```

JS:
```private class GrpcProfileClient(
    private val client: Client
) : ProfileService {
    override suspend fun get(userId: UserId): Profile? {
        val token = (coroutineContext[PrincipalContext.Key]?.principal as? JwtPrincipal)?.bearerToken
        val result = CompletableDeferred&lt;Profile?&gt;()
        client.makeUnaryRequest&lt;pl.mensa.skillmatrix.schema.model.UserId, pl.mensa.skillmatrix.schema.model.Profile?&gt;(
            "/pl.mensa.skillmatrix.schema.service.ProfileService/Get",
            { value -&gt;
                Buffer.from(value.encodeToByteArray())
            },
            { pl.mensa.skillmatrix.schema.model.Profile.decodeFromByteArray(it.unsafeCast&lt;ByteArray&gt;()) },
            userId.toSchema(),
            Metadata(),
            CallOptions(
                credentials = createFromMetadataGenerator { _, callback -&gt;
                    val metadata = Metadata()
                    if (token != null) {
                        metadata.set("Authorization", "Bearer ${token.accessToken}")
                    }
                    callback(null, metadata)
                }
            ),
            { error, value -&gt;
                val errorCode = error?.code
                if (errorCode == null || errorCode == status.OK) {
                    result.complete((value as pl.mensa.skillmatrix.schema.model.Profile?)?.toModel())
                } else {
                    result.completeExceptionally(Exception("Received error from ProfileService/Get call. Error code: $errorCode"))
                }
            }
        )
        return result.await()
    }
}```