starpc 0.0.1 → 0.1.2

package/echo/echo.proto

@@ -0,0 +1,19 @@
+syntax = "proto3";
+package echo;
+
+// Echoer service returns the given message.
+service Echoer {
+  // Echo returns the given message.
+  rpc Echo(EchoMsg) returns (EchoMsg);
+  // EchoServerStream is an example of a server -> client one-way stream.
+  rpc EchoServerStream(EchoMsg) returns (stream EchoMsg);
+  // EchoClientStream is an example of client->server one-way stream.
+  rpc EchoClientStream(stream EchoMsg) returns (EchoMsg);
+  // EchoBidiStream is an example of a two-way stream.
+  rpc EchoBidiStream(stream EchoMsg) returns (stream EchoMsg);
+}
+
+// EchoMsg is the message body for Echo.
+message EchoMsg {
+  string body = 1;
+}

package/echo/echo.ts

@@ -0,0 +1,191 @@
+/* eslint-disable */
+import Long from 'long'
+import * as _m0 from 'protobufjs/minimal'
+import { Observable } from 'rxjs'
+import { map } from 'rxjs/operators'
+
+export const protobufPackage = 'echo'
+
+/** EchoMsg is the message body for Echo. */
+export interface EchoMsg {
+  body: string
+}
+
+function createBaseEchoMsg(): EchoMsg {
+  return { body: '' }
+}
+
+export const EchoMsg = {
+  encode(
+    message: EchoMsg,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.body !== '') {
+      writer.uint32(10).string(message.body)
+    }
+    return writer
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input)
+    let end = length === undefined ? reader.len : reader.pos + length
+    const message = createBaseEchoMsg()
+    while (reader.pos < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.body = reader.string()
+          break
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+    return message
+  },
+
+  fromJSON(object: any): EchoMsg {
+    return {
+      body: isSet(object.body) ? String(object.body) : '',
+    }
+  },
+
+  toJSON(message: EchoMsg): unknown {
+    const obj: any = {}
+    message.body !== undefined && (obj.body = message.body)
+    return obj
+  },
+
+  fromPartial<I extends Exact<DeepPartial<EchoMsg>, I>>(object: I): EchoMsg {
+    const message = createBaseEchoMsg()
+    message.body = object.body ?? ''
+    return message
+  },
+}
+
+/** Echoer service returns the given message. */
+export interface Echoer {
+  /** Echo returns the given message. */
+  Echo(request: EchoMsg): Promise<EchoMsg>
+  /** EchoServerStream is an example of a server -> client one-way stream. */
+  EchoServerStream(request: EchoMsg): Observable<EchoMsg>
+  /** EchoClientStream is an example of client->server one-way stream. */
+  EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg>
+  /** EchoBidiStream is an example of a two-way stream. */
+  EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg>
+}
+
+export class EchoerClientImpl implements Echoer {
+  private readonly rpc: Rpc
+  constructor(rpc: Rpc) {
+    this.rpc = rpc
+    this.Echo = this.Echo.bind(this)
+    this.EchoServerStream = this.EchoServerStream.bind(this)
+    this.EchoClientStream = this.EchoClientStream.bind(this)
+    this.EchoBidiStream = this.EchoBidiStream.bind(this)
+  }
+  Echo(request: EchoMsg): Promise<EchoMsg> {
+    const data = EchoMsg.encode(request).finish()
+    const promise = this.rpc.request('echo.Echoer', 'Echo', data)
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
+  }
+
+  EchoServerStream(request: EchoMsg): Observable<EchoMsg> {
+    const data = EchoMsg.encode(request).finish()
+    const result = this.rpc.serverStreamingRequest(
+      'echo.Echoer',
+      'EchoServerStream',
+      data
+    )
+    return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))))
+  }
+
+  EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg> {
+    const data = request.pipe(
+      map((request) => EchoMsg.encode(request).finish())
+    )
+    const promise = this.rpc.clientStreamingRequest(
+      'echo.Echoer',
+      'EchoClientStream',
+      data
+    )
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
+  }
+
+  EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg> {
+    const data = request.pipe(
+      map((request) => EchoMsg.encode(request).finish())
+    )
+    const result = this.rpc.bidirectionalStreamingRequest(
+      'echo.Echoer',
+      'EchoBidiStream',
+      data
+    )
+    return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))))
+  }
+}
+
+interface Rpc {
+  request(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Promise<Uint8Array>
+  clientStreamingRequest(
+    service: string,
+    method: string,
+    data: Observable<Uint8Array>
+  ): Promise<Uint8Array>
+  serverStreamingRequest(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Observable<Uint8Array>
+  bidirectionalStreamingRequest(
+    service: string,
+    method: string,
+    data: Observable<Uint8Array>
+  ): Observable<Uint8Array>
+}
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined
+
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Long
+  ? string | number | Long
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string }
+  ? { [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]> } & {
+      $case: T['$case']
+    }
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>
+
+type KeysOfUnion<T> = T extends T ? keyof T : never
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
+        Exclude<keyof I, KeysOfUnion<P>>,
+        never
+      >
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any
+  _m0.configure()
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined
+}

package/echo/echo_srpc.pb.go

@@ -0,0 +1,333 @@
+// Code generated by protoc-gen-srpc. DO NOT EDIT.
+// protoc-gen-srpc version: v0.0.0-20220611014014-aa9dc5523865
+// source: github.com/aperturerobotics/starpc/echo/echo.proto
+
+package echo
+
+import (
+	context "context"
+
+	srpc "github.com/aperturerobotics/starpc/srpc"
+)
+
+type SRPCEchoerClient interface {
+	SRPCClient() srpc.Client
+
+	Echo(ctx context.Context, in *EchoMsg) (*EchoMsg, error)
+	EchoServerStream(ctx context.Context, in *EchoMsg) (SRPCEchoer_EchoServerStreamClient, error)
+	EchoClientStream(ctx context.Context) (SRPCEchoer_EchoClientStreamClient, error)
+	EchoBidiStream(ctx context.Context) (SRPCEchoer_EchoBidiStreamClient, error)
+}
+
+type srpcEchoerClient struct {
+	cc srpc.Client
+}
+
+func NewSRPCEchoerClient(cc srpc.Client) SRPCEchoerClient {
+	return &srpcEchoerClient{cc}
+}
+
+func (c *srpcEchoerClient) SRPCClient() srpc.Client { return c.cc }
+
+func (c *srpcEchoerClient) Echo(ctx context.Context, in *EchoMsg) (*EchoMsg, error) {
+	out := new(EchoMsg)
+	err := c.cc.Invoke(ctx, "echo.Echoer", "Echo", in, out)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *srpcEchoerClient) EchoServerStream(ctx context.Context, in *EchoMsg) (SRPCEchoer_EchoServerStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoServerStream", in)
+	if err != nil {
+		return nil, err
+	}
+	strm := &srpcEchoer_EchoServerStreamClient{stream}
+	if err := strm.CloseSend(); err != nil {
+		return nil, err
+	}
+	return strm, nil
+}
+
+type SRPCEchoer_EchoServerStreamClient interface {
+	srpc.Stream
+	Recv() (*EchoMsg, error)
+	RecvTo(*EchoMsg) error
+}
+
+type srpcEchoer_EchoServerStreamClient struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_EchoServerStreamClient) Recv() (*EchoMsg, error) {
+	m := new(EchoMsg)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_EchoServerStreamClient) RecvTo(m *EchoMsg) error {
+	return x.MsgRecv(m)
+}
+
+func (c *srpcEchoerClient) EchoClientStream(ctx context.Context) (SRPCEchoer_EchoClientStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoClientStream", nil)
+	if err != nil {
+		return nil, err
+	}
+	strm := &srpcEchoer_EchoClientStreamClient{stream}
+	return strm, nil
+}
+
+type SRPCEchoer_EchoClientStreamClient interface {
+	srpc.Stream
+	Send(*EchoMsg) error
+	CloseAndRecv() (*EchoMsg, error)
+}
+
+type srpcEchoer_EchoClientStreamClient struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_EchoClientStreamClient) Send(m *EchoMsg) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcEchoer_EchoClientStreamClient) CloseAndRecv() (*EchoMsg, error) {
+	if err := x.CloseSend(); err != nil {
+		return nil, err
+	}
+	m := new(EchoMsg)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_EchoClientStreamClient) CloseAndMsgRecv(m *EchoMsg) error {
+	if err := x.CloseSend(); err != nil {
+		return err
+	}
+	return x.MsgRecv(m)
+}
+
+func (c *srpcEchoerClient) EchoBidiStream(ctx context.Context) (SRPCEchoer_EchoBidiStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoBidiStream", nil)
+	if err != nil {
+		return nil, err
+	}
+	strm := &srpcEchoer_EchoBidiStreamClient{stream}
+	return strm, nil
+}
+
+type SRPCEchoer_EchoBidiStreamClient interface {
+	srpc.Stream
+	Send(*EchoMsg) error
+	Recv() (*EchoMsg, error)
+	RecvTo(*EchoMsg) error
+}
+
+type srpcEchoer_EchoBidiStreamClient struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_EchoBidiStreamClient) Send(m *EchoMsg) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcEchoer_EchoBidiStreamClient) Recv() (*EchoMsg, error) {
+	m := new(EchoMsg)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_EchoBidiStreamClient) RecvTo(m *EchoMsg) error {
+	return x.MsgRecv(m)
+}
+
+type SRPCEchoerServer interface {
+	Echo(context.Context, *EchoMsg) (*EchoMsg, error)
+	EchoServerStream(*EchoMsg, SRPCEchoer_EchoServerStreamStream) error
+	EchoClientStream(SRPCEchoer_EchoClientStreamStream) error
+	EchoBidiStream(SRPCEchoer_EchoBidiStreamStream) error
+}
+
+type SRPCEchoerUnimplementedServer struct{}
+
+func (s *SRPCEchoerUnimplementedServer) Echo(context.Context, *EchoMsg) (*EchoMsg, error) {
+	return nil, srpc.ErrUnimplemented
+}
+
+func (s *SRPCEchoerUnimplementedServer) EchoServerStream(*EchoMsg, SRPCEchoer_EchoServerStreamStream) error {
+	return srpc.ErrUnimplemented
+}
+
+func (s *SRPCEchoerUnimplementedServer) EchoClientStream(SRPCEchoer_EchoClientStreamStream) error {
+	return srpc.ErrUnimplemented
+}
+
+func (s *SRPCEchoerUnimplementedServer) EchoBidiStream(SRPCEchoer_EchoBidiStreamStream) error {
+	return srpc.ErrUnimplemented
+}
+
+const SRPCEchoerServiceID = "echo.Echoer"
+
+type SRPCEchoerHandler struct {
+	impl SRPCEchoerServer
+}
+
+func (SRPCEchoerHandler) GetServiceID() string { return SRPCEchoerServiceID }
+
+func (SRPCEchoerHandler) GetMethodIDs() []string {
+	return []string{
+		"Echo",
+		"EchoServerStream",
+		"EchoClientStream",
+		"EchoBidiStream",
+	}
+}
+
+func (d *SRPCEchoerHandler) InvokeMethod(
+	serviceID, methodID string,
+	strm srpc.Stream,
+) (bool, error) {
+	if serviceID != "" && serviceID != d.GetServiceID() {
+		return false, nil
+	}
+
+	switch methodID {
+	case "Echo":
+		return true, d.InvokeMethod_Echo(d.impl, strm)
+	case "EchoServerStream":
+		return true, d.InvokeMethod_EchoServerStream(d.impl, strm)
+	case "EchoClientStream":
+		return true, d.InvokeMethod_EchoClientStream(d.impl, strm)
+	case "EchoBidiStream":
+		return true, d.InvokeMethod_EchoBidiStream(d.impl, strm)
+	default:
+		return false, nil
+	}
+}
+
+func (SRPCEchoerHandler) InvokeMethod_Echo(impl SRPCEchoerServer, strm srpc.Stream) error {
+	req := new(EchoMsg)
+	if err := strm.MsgRecv(req); err != nil {
+		return err
+	}
+	out, err := impl.Echo(strm.Context(), req)
+	if err != nil {
+		return err
+	}
+	return strm.MsgSend(out)
+}
+
+func (SRPCEchoerHandler) InvokeMethod_EchoServerStream(impl SRPCEchoerServer, strm srpc.Stream) error {
+	req := new(EchoMsg)
+	if err := strm.MsgRecv(req); err != nil {
+		return err
+	}
+	serverStrm := &srpcEchoer_EchoServerStreamStream{strm}
+	return impl.EchoServerStream(req, serverStrm)
+}
+
+func (SRPCEchoerHandler) InvokeMethod_EchoClientStream(impl SRPCEchoerServer, strm srpc.Stream) error {
+	clientStrm := &srpcEchoer_EchoClientStreamStream{strm}
+	return impl.EchoClientStream(clientStrm)
+}
+
+func (SRPCEchoerHandler) InvokeMethod_EchoBidiStream(impl SRPCEchoerServer, strm srpc.Stream) error {
+	clientStrm := &srpcEchoer_EchoBidiStreamStream{strm}
+	return impl.EchoBidiStream(clientStrm)
+}
+
+func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
+	return mux.Register(&SRPCEchoerHandler{impl: impl})
+}
+
+type SRPCEchoer_EchoStream interface {
+	srpc.Stream
+	SendAndClose(*EchoMsg) error
+}
+
+type srpcEchoer_EchoStream struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_EchoStream) SendAndClose(m *EchoMsg) error {
+	if err := x.MsgSend(m); err != nil {
+		return err
+	}
+	return x.CloseSend()
+}
+
+type SRPCEchoer_EchoServerStreamStream interface {
+	srpc.Stream
+	Send(*EchoMsg) error
+}
+
+type srpcEchoer_EchoServerStreamStream struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_EchoServerStreamStream) Send(m *EchoMsg) error {
+	return x.MsgSend(m)
+}
+
+type SRPCEchoer_EchoClientStreamStream interface {
+	srpc.Stream
+	SendAndClose(*EchoMsg) error
+	Recv() (*EchoMsg, error)
+}
+
+type srpcEchoer_EchoClientStreamStream struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_EchoClientStreamStream) SendAndClose(m *EchoMsg) error {
+	if err := x.MsgSend(m); err != nil {
+		return err
+	}
+	return x.CloseSend()
+}
+
+func (x *srpcEchoer_EchoClientStreamStream) Recv() (*EchoMsg, error) {
+	m := new(EchoMsg)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_EchoClientStreamStream) RecvTo(m *EchoMsg) error {
+	return x.MsgRecv(m)
+}
+
+type SRPCEchoer_EchoBidiStreamStream interface {
+	srpc.Stream
+	Send(*EchoMsg) error
+	Recv() (*EchoMsg, error)
+}
+
+type srpcEchoer_EchoBidiStreamStream struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_EchoBidiStreamStream) Send(m *EchoMsg) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcEchoer_EchoBidiStreamStream) Recv() (*EchoMsg, error) {
+	m := new(EchoMsg)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_EchoBidiStreamStream) RecvTo(m *EchoMsg) error {
+	return x.MsgRecv(m)
+}