starpc 0.30.0 → 0.31.0

package/Makefile

@@ -77,27 +77,25 @@ genproto: vendor node_modules $(GOIMPORTS) $(PROTOWRAP) $(PROTOC_GEN_GO) $(PROTO
 	set -eo pipefail; \
 	export PROJECT=$$(go list -m); \
 	export PATH=$$(pwd)/hack/bin:$${PATH}; \
-	mkdir -p $$(pwd)/vendor/$$(dirname $${PROJECT}); \
+	export OUT=$$(pwd)/vendor; \
+	mkdir -p $${OUT}/$$(dirname $${PROJECT}); \
 	rm $$(pwd)/vendor/$${PROJECT} || true; \
 	ln -s $$(pwd) $$(pwd)/vendor/$${PROJECT} ; \
 	protogen() { \
 		$(PROTOWRAP) \
-			-I $$(pwd)/vendor \
-			--plugin=./node_modules/.bin/protoc-gen-ts_proto \
-			--go-lite_out=$$(pwd)/vendor \
+			-I $${OUT} \
+			--plugin=./node_modules/.bin/protoc-gen-es \
+			--plugin=./cmd/protoc-gen-es-starpc/protoc-gen-es-starpc \
+			--go-lite_out=$${OUT} \
 			--go-lite_opt=features=marshal+unmarshal+size+equal+json+clone \
-			--go-starpc_out=$$(pwd)/vendor \
-			--ts_proto_out=$$(pwd)/vendor \
-			--ts_proto_opt=esModuleInterop=true \
-			--ts_proto_opt=fileSuffix=.pb \
-			--ts_proto_opt=importSuffix=.js \
-			--ts_proto_opt=forceLong=long \
-			--ts_proto_opt=oneof=unions \
-			--ts_proto_opt=outputServices=default,outputServices=generic-definitions \
-			--ts_proto_opt=useAbortSignal=true \
-			--ts_proto_opt=useAsyncIterable=true \
-			--ts_proto_opt=useDate=true \
-			--proto_path $$(pwd)/vendor \
+			--go-starpc_out=$${OUT} \
+			--es_out=$${OUT} \
+			--es_opt target=ts \
+			--es_opt ts_nocheck=false \
+			--es-starpc_out=$${OUT} \
+			--es-starpc_opt target=ts \
+			--es-starpc_opt ts_nocheck=false \
+			--proto_path $${OUT} \
 			--print_structure \
 			--only_specified_files \
 			$$(\

package/README.md

@@ -26,6 +26,10 @@ Supports **client-to-server and bidirectional streaming** in the web browser.
 The library leverages libp2p streams with `@chainsafe/libp2p-yamux` to
 coordinate balancing many ongoing RPCs over a single connection.
 
+starpc uses [protobuf-go-lite] to generate reflection-free Go code.
+
+[protobuf-go-lite]: https://github.com/aperturerobotics/protobuf-go-lite
+
 ## Usage
 
 Start with the [protobuf-project] template repository on the "starpc" branch.
@@ -121,12 +125,12 @@ This examples demonstrates connecting to a WebSocket server:
 
 ```typescript
 import { WebSocketConn } from 'srpc'
-import { EchoerClientImpl } from 'srpc/echo'
+import { EchoerClient } from 'srpc/echo'
 
 const ws = new WebSocket('ws://localhost:5000/demo')
 const channel = new WebSocketConn(ws)
 const client = channel.buildClient()
-const demoServiceClient = new EchoerClientImpl(client)
+const demoServiceClient = new EchoerClient(client)
 
 const result = await demoServiceClient.Echo({
   body: "Hello world!"
@@ -195,6 +199,12 @@ Uses [vtprotobuf] to generate Protobuf marshal / unmarshal code.
 
 [vtprotobuf]: https://github.com/planetscale/vtprotobuf
 
+Uses [protobuf-es] to serialize Protobuf in TypeScript.
+
+[protobuf-es]: https://github.com/bufbuild/protobuf-es
+
+`protoc-gen-es-starpc` is a heavily modified version of `protoc-gen-connect-es`.
+
 ## Developing on MacOS
 
 On MacOS, some homebrew packages are required for `yarn gen`:

package/cmd/protoc-gen-es-starpc/plugin.ts

@@ -0,0 +1,24 @@
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { createEcmaScriptPlugin } from '@bufbuild/protoplugin'
+import { generateTs } from './typescript.js'
+import { version } from '../../package.json'
+
+export const protocGenEsStarpc = createEcmaScriptPlugin({
+  name: 'protoc-gen-es-starpc',
+  version: `v${String(version)}`,
+  generateTs,
+})

package/cmd/protoc-gen-es-starpc/protoc-gen-es-starpc

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec tsx "./cmd/protoc-gen-es-starpc/protoc-gen-es-starpc.ts" "$@"

package/cmd/protoc-gen-es-starpc/protoc-gen-es-starpc.ts

@@ -0,0 +1,19 @@
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { runNodeJs } from '@bufbuild/protoplugin'
+import { protocGenEsStarpc } from './plugin.js'
+
+runNodeJs(protocGenEsStarpc)

package/cmd/protoc-gen-es-starpc/typescript.ts

@@ -0,0 +1,183 @@
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import type { DescService } from '@bufbuild/protobuf'
+import { MethodIdempotency, MethodKind } from '@bufbuild/protobuf'
+import type { GeneratedFile, Schema } from '@bufbuild/protoplugin/ecmascript'
+import { createImportSymbol, localName } from '@bufbuild/protoplugin/ecmascript'
+
+export function generateTs(schema: Schema) {
+  for (const protoFile of schema.files) {
+    const file = schema.generateFile(protoFile.name + '_srpc.pb.ts')
+    file.preamble(protoFile)
+    for (const service of protoFile.services) {
+      generateService(schema, file, service)
+    }
+  }
+}
+
+// prettier-ignore
+function generateService(
+  schema: Schema,
+  f: GeneratedFile,
+  service: DescService
+) {
+  const { MethodKind: rtMethodKind, MethodIdempotency: rtMethodIdempotency, PartialMessage } =
+    schema.runtime;
+  const MessageStream = createImportSymbol("MessageStream", "starpc")
+
+// NOTE: This matches generateService from @connectrpc/protoc-gen-connect-es.
+  f.print(f.jsDoc(service));
+  f.print(f.exportDecl("const", localName(service)), "Definition = {");
+  f.print(`  typeName: `, f.string(service.typeName), `,`);
+  f.print("  methods: {");
+  for (const method of service.methods) {
+    f.print(f.jsDoc(method, "    "));
+    f.print("    ", method.name, ": {");
+    f.print(`      name: `, f.string(method.name), `,`);
+    f.print("      I: ", method.input, ",");
+    f.print("      O: ", method.output, ",");
+    f.print(
+      "      kind: ",
+      rtMethodKind,
+      ".",
+      MethodKind[method.methodKind],
+      ","
+    );
+    if (method.idempotency !== undefined) {
+      f.print(
+        "      idempotency: ",
+        rtMethodIdempotency,
+        ".",
+        MethodIdempotency[method.idempotency],
+        ","
+      );
+    }
+    // In case we start supporting options, we have to surface them here
+    f.print("    },");
+  }
+  f.print("  }");
+  f.print("} as const;");
+  f.print();
+
+  // Generate the service interface
+  f.print(f.jsDoc(service));
+  f.print("export interface ", localName(service), " {");
+  for (const method of service.methods) {
+    f.print(f.jsDoc(method, "  "));
+    f.print("  ", method.name, "(");
+    if (method.methodKind === MethodKind.Unary) {
+      f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+    } else if (method.methodKind === MethodKind.ServerStreaming) {
+      f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+    } else if (method.methodKind === MethodKind.ClientStreaming) {
+      f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+    } else if (method.methodKind === MethodKind.BiDiStreaming) {
+      f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+    }
+    f.print("): ");
+    if (method.methodKind === MethodKind.Unary) {
+      f.print("Promise<", PartialMessage, "<", method.output, ">>");
+    } else if (method.methodKind === MethodKind.ServerStreaming) {
+      f.print(MessageStream, "<", method.output, ">");
+    } else if (method.methodKind === MethodKind.ClientStreaming) {
+      f.print("Promise<", PartialMessage, "<", method.output, ">>");
+    } else if (method.methodKind === MethodKind.BiDiStreaming) {
+      f.print(MessageStream, "<", method.output, ">");
+    }
+    f.print();
+  }
+  f.print("}");
+  f.print();
+
+
+  // Generate the service name constant
+  f.print("export const ", localName(service), "ServiceName = ", localName(service), "Definition.typeName");
+  f.print();
+
+  // Generate the client implementation
+  f.print("export class ", localName(service), "Client implements ", localName(service), " {");
+  f.print("  private readonly rpc: ", createImportSymbol("ProtoRpc", "starpc"));
+  f.print("  private readonly service: string");
+  f.print("  constructor(rpc: ProtoRpc, opts?: { service?: string }) {");
+  f.print("    this.service = opts?.service || ", localName(service), "ServiceName");
+  f.print("    this.rpc = rpc");
+  for (const method of service.methods) {
+    f.print("    this.", method.name, " = this.", method.name, ".bind(this)");
+  }
+  f.print("  }");
+
+  const buildDecodeMessageTransformSymbol = createImportSymbol("buildDecodeMessageTransform", "starpc")
+  const buildEncodeMessageTransformSymbol = createImportSymbol("buildEncodeMessageTransform", "starpc")
+  for (const method of service.methods) {
+    f.print(f.jsDoc(method, "  "));
+    f.print("  ", method.methodKind === MethodKind.Unary || method.methodKind === MethodKind.ClientStreaming ? "async " : "", method.name, "(");
+    if (method.methodKind === MethodKind.Unary) {
+      f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+    } else if (method.methodKind === MethodKind.ServerStreaming) {
+      f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+    } else if (method.methodKind === MethodKind.ClientStreaming) {
+      f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+    } else if (method.methodKind === MethodKind.BiDiStreaming) {
+      f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+    }
+    f.print("): ");
+    if (method.methodKind === MethodKind.Unary) {
+      f.print("Promise<", PartialMessage, "<", method.output, ">> {");
+      f.print("    const requestMsg = new ", method.input, "(request)");
+      f.print("    const result = await this.rpc.request(");
+      f.print("      this.service,");
+      f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+      f.print("      requestMsg.toBinary(),");
+      f.print("      abortSignal || undefined,");
+      f.print("    )");
+      f.print("    return ", method.output, ".fromBinary(result)");
+      f.print("  }");
+    } else if (method.methodKind === MethodKind.ServerStreaming) {
+      f.print(MessageStream, "<", method.output, "> {");
+      f.print("    const requestMsg = new ", method.input, "(request)");
+      f.print("    const result = this.rpc.serverStreamingRequest(");
+      f.print("      this.service,");
+      f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+      f.print("      requestMsg.toBinary(),");
+      f.print("      abortSignal || undefined,");
+      f.print("    )");
+      f.print("    return ", buildDecodeMessageTransformSymbol, "(", method.output, ")(result)");
+      f.print("  }");
+    } else if (method.methodKind === MethodKind.ClientStreaming) {
+      f.print("Promise<", PartialMessage, "<", method.output, ">> {");
+      f.print("    const result = await this.rpc.clientStreamingRequest(");
+      f.print("      this.service,");
+      f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+      f.print("      ", buildEncodeMessageTransformSymbol, "(", method.input, ")(request),");
+      f.print("      abortSignal || undefined,");
+      f.print("    )");
+      f.print("    return ", method.output, ".fromBinary(result)");
+      f.print("  }");
+    } else if (method.methodKind === MethodKind.BiDiStreaming) {
+      f.print(MessageStream, "<", method.output, "> {");
+      f.print("    const result = this.rpc.bidirectionalStreamingRequest(");
+      f.print("      this.service,");
+      f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+      f.print("      ", buildEncodeMessageTransformSymbol, "(", method.input, ")(request),");
+      f.print("      abortSignal || undefined,");
+      f.print("    )");
+      f.print("    return ", buildDecodeMessageTransformSymbol, "(", method.output, ")(result)");
+      f.print("  }");
+    }
+    f.print();
+  }
+  f.print("}");
+}

package/dist/cmd/protoc-gen-es-starpc/plugin.d.ts

@@ -0,0 +1 @@
+export declare const protocGenEsStarpc: import("@bufbuild/protoplugin").Plugin;

package/dist/cmd/protoc-gen-es-starpc/plugin.js

@@ -0,0 +1,22 @@
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { createEcmaScriptPlugin } from '@bufbuild/protoplugin';
+import { generateTs } from './typescript.js';
+import { version } from '../../package.json';
+export const protocGenEsStarpc = createEcmaScriptPlugin({
+    name: 'protoc-gen-es-starpc',
+    version: `v${String(version)}`,
+    generateTs,
+});

package/dist/cmd/protoc-gen-es-starpc/protoc-gen-es-starpc.js

@@ -0,0 +1,17 @@
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { runNodeJs } from '@bufbuild/protoplugin';
+import { protocGenEsStarpc } from './plugin.js';
+runNodeJs(protocGenEsStarpc);

package/dist/cmd/protoc-gen-es-starpc/typescript.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '@bufbuild/protoplugin/ecmascript';
+export declare function generateTs(schema: Schema): void;

package/dist/cmd/protoc-gen-es-starpc/typescript.js

@@ -0,0 +1,167 @@
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { MethodIdempotency, MethodKind } from '@bufbuild/protobuf';
+import { createImportSymbol, localName } from '@bufbuild/protoplugin/ecmascript';
+export function generateTs(schema) {
+    for (const protoFile of schema.files) {
+        const file = schema.generateFile(protoFile.name + '_srpc.pb.ts');
+        file.preamble(protoFile);
+        for (const service of protoFile.services) {
+            generateService(schema, file, service);
+        }
+    }
+}
+// prettier-ignore
+function generateService(schema, f, service) {
+    const { MethodKind: rtMethodKind, MethodIdempotency: rtMethodIdempotency, PartialMessage } = schema.runtime;
+    const MessageStream = createImportSymbol("MessageStream", "starpc");
+    // NOTE: This matches generateService from @connectrpc/protoc-gen-connect-es.
+    f.print(f.jsDoc(service));
+    f.print(f.exportDecl("const", localName(service)), "Definition = {");
+    f.print(`  typeName: `, f.string(service.typeName), `,`);
+    f.print("  methods: {");
+    for (const method of service.methods) {
+        f.print(f.jsDoc(method, "    "));
+        f.print("    ", method.name, ": {");
+        f.print(`      name: `, f.string(method.name), `,`);
+        f.print("      I: ", method.input, ",");
+        f.print("      O: ", method.output, ",");
+        f.print("      kind: ", rtMethodKind, ".", MethodKind[method.methodKind], ",");
+        if (method.idempotency !== undefined) {
+            f.print("      idempotency: ", rtMethodIdempotency, ".", MethodIdempotency[method.idempotency], ",");
+        }
+        // In case we start supporting options, we have to surface them here
+        f.print("    },");
+    }
+    f.print("  }");
+    f.print("} as const;");
+    f.print();
+    // Generate the service interface
+    f.print(f.jsDoc(service));
+    f.print("export interface ", localName(service), " {");
+    for (const method of service.methods) {
+        f.print(f.jsDoc(method, "  "));
+        f.print("  ", method.name, "(");
+        if (method.methodKind === MethodKind.Unary) {
+            f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        else if (method.methodKind === MethodKind.ServerStreaming) {
+            f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        else if (method.methodKind === MethodKind.ClientStreaming) {
+            f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        else if (method.methodKind === MethodKind.BiDiStreaming) {
+            f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        f.print("): ");
+        if (method.methodKind === MethodKind.Unary) {
+            f.print("Promise<", PartialMessage, "<", method.output, ">>");
+        }
+        else if (method.methodKind === MethodKind.ServerStreaming) {
+            f.print(MessageStream, "<", method.output, ">");
+        }
+        else if (method.methodKind === MethodKind.ClientStreaming) {
+            f.print("Promise<", PartialMessage, "<", method.output, ">>");
+        }
+        else if (method.methodKind === MethodKind.BiDiStreaming) {
+            f.print(MessageStream, "<", method.output, ">");
+        }
+        f.print();
+    }
+    f.print("}");
+    f.print();
+    // Generate the service name constant
+    f.print("export const ", localName(service), "ServiceName = ", localName(service), "Definition.typeName");
+    f.print();
+    // Generate the client implementation
+    f.print("export class ", localName(service), "Client implements ", localName(service), " {");
+    f.print("  private readonly rpc: ", createImportSymbol("ProtoRpc", "starpc"));
+    f.print("  private readonly service: string");
+    f.print("  constructor(rpc: ProtoRpc, opts?: { service?: string }) {");
+    f.print("    this.service = opts?.service || ", localName(service), "ServiceName");
+    f.print("    this.rpc = rpc");
+    for (const method of service.methods) {
+        f.print("    this.", method.name, " = this.", method.name, ".bind(this)");
+    }
+    f.print("  }");
+    const buildDecodeMessageTransformSymbol = createImportSymbol("buildDecodeMessageTransform", "starpc");
+    const buildEncodeMessageTransformSymbol = createImportSymbol("buildEncodeMessageTransform", "starpc");
+    for (const method of service.methods) {
+        f.print(f.jsDoc(method, "  "));
+        f.print("  ", method.methodKind === MethodKind.Unary || method.methodKind === MethodKind.ClientStreaming ? "async " : "", method.name, "(");
+        if (method.methodKind === MethodKind.Unary) {
+            f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        else if (method.methodKind === MethodKind.ServerStreaming) {
+            f.print("request: ", PartialMessage, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        else if (method.methodKind === MethodKind.ClientStreaming) {
+            f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        else if (method.methodKind === MethodKind.BiDiStreaming) {
+            f.print("request: ", MessageStream, "<", method.input, ">, abortSignal?: AbortSignal");
+        }
+        f.print("): ");
+        if (method.methodKind === MethodKind.Unary) {
+            f.print("Promise<", PartialMessage, "<", method.output, ">> {");
+            f.print("    const requestMsg = new ", method.input, "(request)");
+            f.print("    const result = await this.rpc.request(");
+            f.print("      this.service,");
+            f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+            f.print("      requestMsg.toBinary(),");
+            f.print("      abortSignal || undefined,");
+            f.print("    )");
+            f.print("    return ", method.output, ".fromBinary(result)");
+            f.print("  }");
+        }
+        else if (method.methodKind === MethodKind.ServerStreaming) {
+            f.print(MessageStream, "<", method.output, "> {");
+            f.print("    const requestMsg = new ", method.input, "(request)");
+            f.print("    const result = this.rpc.serverStreamingRequest(");
+            f.print("      this.service,");
+            f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+            f.print("      requestMsg.toBinary(),");
+            f.print("      abortSignal || undefined,");
+            f.print("    )");
+            f.print("    return ", buildDecodeMessageTransformSymbol, "(", method.output, ")(result)");
+            f.print("  }");
+        }
+        else if (method.methodKind === MethodKind.ClientStreaming) {
+            f.print("Promise<", PartialMessage, "<", method.output, ">> {");
+            f.print("    const result = await this.rpc.clientStreamingRequest(");
+            f.print("      this.service,");
+            f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+            f.print("      ", buildEncodeMessageTransformSymbol, "(", method.input, ")(request),");
+            f.print("      abortSignal || undefined,");
+            f.print("    )");
+            f.print("    return ", method.output, ".fromBinary(result)");
+            f.print("  }");
+        }
+        else if (method.methodKind === MethodKind.BiDiStreaming) {
+            f.print(MessageStream, "<", method.output, "> {");
+            f.print("    const result = this.rpc.bidirectionalStreamingRequest(");
+            f.print("      this.service,");
+            f.print("      ", localName(service), "Definition.methods.", method.name, ".name,");
+            f.print("      ", buildEncodeMessageTransformSymbol, "(", method.input, ")(request),");
+            f.print("      abortSignal || undefined,");
+            f.print("    )");
+            f.print("    return ", buildDecodeMessageTransformSymbol, "(", method.output, ")(result)");
+            f.print("  }");
+        }
+        f.print();
+    }
+    f.print("}");
+}

package/dist/e2e/mock/mock_pb.d.ts

@@ -0,0 +1,21 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from '@bufbuild/protobuf';
+import { Message, proto3 } from '@bufbuild/protobuf';
+/**
+ * MockMsg is the mock message body.
+ *
+ * @generated from message e2e.mock.MockMsg
+ */
+export declare class MockMsg extends Message<MockMsg> {
+    /**
+     * @generated from field: string body = 1;
+     */
+    body: string;
+    constructor(data?: PartialMessage<MockMsg>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "e2e.mock.MockMsg";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MockMsg;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MockMsg;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MockMsg;
+    static equals(a: MockMsg | PlainMessage<MockMsg> | undefined, b: MockMsg | PlainMessage<MockMsg> | undefined): boolean;
+}

package/dist/e2e/mock/mock_pb.js

@@ -0,0 +1,36 @@
+// @generated by protoc-gen-es v1.8.0 with parameter "target=ts,ts_nocheck=false"
+// @generated from file github.com/aperturerobotics/starpc/e2e/mock/mock.proto (package e2e.mock, syntax proto3)
+/* eslint-disable */
+import { Message, proto3 } from '@bufbuild/protobuf';
+/**
+ * MockMsg is the mock message body.
+ *
+ * @generated from message e2e.mock.MockMsg
+ */
+export class MockMsg extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string body = 1;
+         */
+        this.body = '';
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MockMsg().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MockMsg().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MockMsg().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MockMsg, a, b);
+    }
+}
+MockMsg.runtime = proto3;
+MockMsg.typeName = 'e2e.mock.MockMsg';
+MockMsg.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: 'body', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+]);

package/dist/e2e/mock/mock_srpc.pb.d.ts

@@ -0,0 +1,52 @@
+import { MockMsg } from './mock_pb.js';
+import type { PartialMessage } from '@bufbuild/protobuf';
+import { MethodKind } from '@bufbuild/protobuf';
+import { ProtoRpc } from 'starpc';
+/**
+ * Mock service mocks some RPCs for the e2e tests.
+ *
+ * @generated from service e2e.mock.Mock
+ */
+export declare const MockDefinition: {
+    readonly typeName: "e2e.mock.Mock";
+    readonly methods: {
+        /**
+         * MockRequest runs a mock unary request.
+         *
+         * @generated from rpc e2e.mock.Mock.MockRequest
+         */
+        readonly MockRequest: {
+            readonly name: "MockRequest";
+            readonly I: typeof MockMsg;
+            readonly O: typeof MockMsg;
+            readonly kind: MethodKind.Unary;
+        };
+    };
+};
+/**
+ * Mock service mocks some RPCs for the e2e tests.
+ *
+ * @generated from service e2e.mock.Mock
+ */
+export interface Mock {
+    /**
+     * MockRequest runs a mock unary request.
+     *
+     * @generated from rpc e2e.mock.Mock.MockRequest
+     */
+    MockRequest(request: PartialMessage<MockMsg>, abortSignal?: AbortSignal): Promise<PartialMessage<MockMsg>>;
+}
+export declare const MockServiceName: "e2e.mock.Mock";
+export declare class MockClient implements Mock {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: ProtoRpc, opts?: {
+        service?: string;
+    });
+    /**
+     * MockRequest runs a mock unary request.
+     *
+     * @generated from rpc e2e.mock.Mock.MockRequest
+     */
+    MockRequest(request: PartialMessage<MockMsg>, abortSignal?: AbortSignal): Promise<PartialMessage<MockMsg>>;
+}