starpc 0.13.2 → 0.14.0

package/e2e/mock/mock.pb.ts

@@ -0,0 +1,182 @@
+/* eslint-disable */
+import Long from 'long'
+import _m0 from 'protobufjs/minimal.js'
+
+export const protobufPackage = 'e2e.mock'
+
+/** MockMsg is the mock message body. */
+export interface MockMsg {
+  body: string
+}
+
+function createBaseMockMsg(): MockMsg {
+  return { body: '' }
+}
+
+export const MockMsg = {
+  encode(
+    message: MockMsg,
+    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): MockMsg {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input)
+    let end = length === undefined ? reader.len : reader.pos + length
+    const message = createBaseMockMsg()
+    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
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<MockMsg, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<MockMsg | MockMsg[]> | Iterable<MockMsg | MockMsg[]>
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [MockMsg.encode(p).finish()]
+        }
+      } else {
+        yield* [MockMsg.encode(pkt).finish()]
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, MockMsg>
+  async *decodeTransform(
+    source:
+      | AsyncIterable<Uint8Array | Uint8Array[]>
+      | Iterable<Uint8Array | Uint8Array[]>
+  ): AsyncIterable<MockMsg> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [MockMsg.decode(p)]
+        }
+      } else {
+        yield* [MockMsg.decode(pkt)]
+      }
+    }
+  },
+
+  fromJSON(object: any): MockMsg {
+    return { body: isSet(object.body) ? String(object.body) : '' }
+  },
+
+  toJSON(message: MockMsg): unknown {
+    const obj: any = {}
+    message.body !== undefined && (obj.body = message.body)
+    return obj
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MockMsg>, I>>(object: I): MockMsg {
+    const message = createBaseMockMsg()
+    message.body = object.body ?? ''
+    return message
+  },
+}
+
+/** Mock service mocks some RPCs for the e2e tests. */
+export interface Mock {
+  /** MockRequest runs a mock unary request. */
+  MockRequest(request: MockMsg): Promise<MockMsg>
+}
+
+export class MockClientImpl implements Mock {
+  private readonly rpc: Rpc
+  private readonly service: string
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || 'e2e.mock.Mock'
+    this.rpc = rpc
+    this.MockRequest = this.MockRequest.bind(this)
+  }
+  MockRequest(request: MockMsg): Promise<MockMsg> {
+    const data = MockMsg.encode(request).finish()
+    const promise = this.rpc.request(this.service, 'MockRequest', data)
+    return promise.then((data) => MockMsg.decode(new _m0.Reader(data)))
+  }
+}
+
+/** Mock service mocks some RPCs for the e2e tests. */
+export type MockDefinition = typeof MockDefinition
+export const MockDefinition = {
+  name: 'Mock',
+  fullName: 'e2e.mock.Mock',
+  methods: {
+    /** MockRequest runs a mock unary request. */
+    mockRequest: {
+      name: 'MockRequest',
+      requestType: MockMsg,
+      requestStream: false,
+      responseType: MockMsg,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const
+
+interface Rpc {
+  request(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Promise<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]> } & {
+      [K in 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/e2e/mock/mock.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+package e2e.mock;
+
+// Mock service mocks some RPCs for the e2e tests.
+service Mock {
+  // MockRequest runs a mock unary request.
+  rpc MockRequest(MockMsg) returns (MockMsg);
+}
+
+// MockMsg is the mock message body.
+message MockMsg {
+  string body = 1;
+}

package/e2e/mock/mock_srpc.pb.go

@@ -0,0 +1,128 @@
+// Code generated by protoc-gen-srpc. DO NOT EDIT.
+// protoc-gen-srpc version: v0.13.2
+// source: github.com/aperturerobotics/starpc/e2e/mock/mock.proto
+
+package e2e_mock
+
+import (
+	context "context"
+
+	srpc "github.com/aperturerobotics/starpc/srpc"
+)
+
+type SRPCMockClient interface {
+	SRPCClient() srpc.Client
+
+	MockRequest(ctx context.Context, in *MockMsg) (*MockMsg, error)
+}
+
+type srpcMockClient struct {
+	cc        srpc.Client
+	serviceID string
+}
+
+func NewSRPCMockClient(cc srpc.Client) SRPCMockClient {
+	return &srpcMockClient{cc: cc, serviceID: SRPCMockServiceID}
+}
+
+func NewSRPCMockClientWithServiceID(cc srpc.Client, serviceID string) SRPCMockClient {
+	if serviceID == "" {
+		serviceID = SRPCMockServiceID
+	}
+	return &srpcMockClient{cc: cc, serviceID: serviceID}
+}
+
+func (c *srpcMockClient) SRPCClient() srpc.Client { return c.cc }
+
+func (c *srpcMockClient) MockRequest(ctx context.Context, in *MockMsg) (*MockMsg, error) {
+	out := new(MockMsg)
+	err := c.cc.ExecCall(ctx, c.serviceID, "MockRequest", in, out)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+type SRPCMockServer interface {
+	MockRequest(context.Context, *MockMsg) (*MockMsg, error)
+}
+
+type SRPCMockUnimplementedServer struct{}
+
+func (s *SRPCMockUnimplementedServer) MockRequest(context.Context, *MockMsg) (*MockMsg, error) {
+	return nil, srpc.ErrUnimplemented
+}
+
+const SRPCMockServiceID = "e2e.mock.Mock"
+
+type SRPCMockHandler struct {
+	serviceID string
+	impl      SRPCMockServer
+}
+
+// NewSRPCMockHandler constructs a new RPC handler.
+// serviceID: if empty, uses default: e2e.mock.Mock
+func NewSRPCMockHandler(impl SRPCMockServer, serviceID string) srpc.Handler {
+	if serviceID == "" {
+		serviceID = SRPCMockServiceID
+	}
+	return &SRPCMockHandler{impl: impl, serviceID: serviceID}
+}
+
+// SRPCRegisterMock registers the implementation with the mux.
+// Uses the default serviceID: e2e.mock.Mock
+func SRPCRegisterMock(mux srpc.Mux, impl SRPCMockServer) error {
+	return mux.Register(NewSRPCMockHandler(impl, ""))
+}
+
+func (d *SRPCMockHandler) GetServiceID() string { return d.serviceID }
+
+func (SRPCMockHandler) GetMethodIDs() []string {
+	return []string{
+		"MockRequest",
+	}
+}
+
+func (d *SRPCMockHandler) InvokeMethod(
+	serviceID, methodID string,
+	strm srpc.Stream,
+) (bool, error) {
+	if serviceID != "" && serviceID != d.GetServiceID() {
+		return false, nil
+	}
+
+	switch methodID {
+	case "MockRequest":
+		return true, d.InvokeMethod_MockRequest(d.impl, strm)
+	default:
+		return false, nil
+	}
+}
+
+func (SRPCMockHandler) InvokeMethod_MockRequest(impl SRPCMockServer, strm srpc.Stream) error {
+	req := new(MockMsg)
+	if err := strm.MsgRecv(req); err != nil {
+		return err
+	}
+	out, err := impl.MockRequest(strm.Context(), req)
+	if err != nil {
+		return err
+	}
+	return strm.MsgSend(out)
+}
+
+type SRPCMock_MockRequestStream interface {
+	srpc.Stream
+	SendAndClose(*MockMsg) error
+}
+
+type srpcMock_MockRequestStream struct {
+	srpc.Stream
+}
+
+func (x *srpcMock_MockRequestStream) SendAndClose(m *MockMsg) error {
+	if err := x.MsgSend(m); err != nil {
+		return err
+	}
+	return x.CloseSend()
+}

package/e2e/mock/mock_vtproto.pb.go

@@ -0,0 +1,290 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.3.1-0.20220817155510-0ae748fd2007
+// source: github.com/aperturerobotics/starpc/e2e/mock/mock.proto
+
+package e2e_mock
+
+import (
+	fmt "fmt"
+	io "io"
+	bits "math/bits"
+
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *MockMsg) CloneVT() *MockMsg {
+	if m == nil {
+		return (*MockMsg)(nil)
+	}
+	r := &MockMsg{
+		Body: m.Body,
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *MockMsg) CloneGenericVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *MockMsg) EqualVT(that *MockMsg) bool {
+	if this == nil {
+		return that == nil
+	} else if that == nil {
+		return false
+	}
+	if this.Body != that.Body {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (m *MockMsg) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MockMsg) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *MockMsg) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if len(m.Body) > 0 {
+		i -= len(m.Body)
+		copy(dAtA[i:], m.Body)
+		i = encodeVarint(dAtA, i, uint64(len(m.Body)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarint(dAtA []byte, offset int, v uint64) int {
+	offset -= sov(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *MockMsg) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Body)
+	if l > 0 {
+		n += 1 + l + sov(uint64(l))
+	}
+	n += len(m.unknownFields)
+	return n
+}
+
+func sov(x uint64) (n int) {
+	return (bits.Len64(x|1) + 6) / 7
+}
+func soz(x uint64) (n int) {
+	return sov(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *MockMsg) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MockMsg: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MockMsg: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Body = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skip(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLength
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroup
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLength
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLength        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflow          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroup = fmt.Errorf("proto: unexpected end of group")
+)