starpc 0.31.6 → 0.31.8

package/srpc/common-rpc.ts

@@ -1,6 +1,6 @@
 import type { Sink, Source } from 'it-stream-types'
 import { pushable } from 'it-pushable'
-import { PartialMessage } from '@bufbuild/protobuf'
+import { CompleteMessage } from '@aptre/protobuf-es-lite'
 
 import type { CallData, CallStart } from './rpcproto_pb.js'
 import { Packet } from './rpcproto_pb.js'
@@ -9,14 +9,14 @@ import { ERR_RPC_ABORT } from './errors.js'
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {
   // sink is the data sink for incoming messages.
-  public readonly sink: Sink<Source<PartialMessage<Packet>>>
+  public readonly sink: Sink<Source<Packet>>
   // source is the packet source for outgoing Packets.
-  public readonly source: AsyncIterable<PartialMessage<Packet>>
+  public readonly source: AsyncIterable<Packet>
   // rpcDataSource is the source for rpc packets.
   public readonly rpcDataSource: AsyncIterable<Uint8Array>
 
   // _source is used to write to the source.
-  private readonly _source = pushable<PartialMessage<Packet>>({
+  private readonly _source = pushable<Packet>({
     objectMode: true,
   })
 
@@ -50,7 +50,7 @@ export class CommonRPC {
     complete?: boolean,
     error?: string,
   ) {
-    const callData: PartialMessage<CallData> = {
+    const callData: CompleteMessage<CallData> = {
       data: data || new Uint8Array(0),
       dataIsZero: !!data && data.length === 0,
       complete: complete || false,
@@ -87,7 +87,7 @@ export class CommonRPC {
   }
 
   // writePacket writes a packet to the stream.
-  protected async writePacket(packet: PartialMessage<Packet>) {
+  protected async writePacket(packet: Packet) {
     this._source.push(packet)
   }
 
@@ -101,7 +101,7 @@ export class CommonRPC {
   // handlePacket handles an incoming packet.
   //
   // note: closes the stream if any error is thrown.
-  public async handlePacket(packet: PartialMessage<Packet>) {
+  public async handlePacket(packet: Packet) {
     // console.log('handlePacket', packet)
     try {
       switch (packet?.body?.case) {
@@ -182,8 +182,8 @@ export class CommonRPC {
   }
 
   // _createSink returns a value for the sink field.
-  private _createSink(): Sink<Source<PartialMessage<Packet>>> {
-    return async (source: Source<PartialMessage<Packet>>) => {
+  private _createSink(): Sink<Source<Packet>> {
+    return async (source: Source<Packet>) => {
       try {
         if (Symbol.asyncIterator in source) {
           // Handle async source

package/srpc/definition.ts

@@ -1,4 +1,5 @@
-import { MessageType, MethodKind, MethodIdempotency } from '@bufbuild/protobuf'
+import { MethodIdempotency, MethodKind } from '@bufbuild/protobuf'
+import { MessageType } from '@aptre/protobuf-es-lite'
 
 // ServiceMethodDefinitions is the type of the methods map on the service definition.
 export type ServiceMethodDefinitions = {

package/srpc/invoker.ts

@@ -8,20 +8,15 @@ import {
   buildEncodeMessageTransform,
 } from './message.js'
 import { writeToPushable } from './pushable.js'
-import {
-  Message,
-  MessageType,
-  MethodIdempotency,
-  MethodKind,
-  PartialMessage,
-} from '@bufbuild/protobuf'
+import type { MessageType, Message } from '@aptre/protobuf-es-lite'
+import { MethodIdempotency, MethodKind } from '@bufbuild/protobuf'
 
 // MethodProto is a function which matches one of the RPC signatures.
 export type MethodProto<R extends Message<R>, O extends Message<O>> =
   | ((request: R) => Promise<O>)
   | ((request: R) => AsyncIterable<O>)
-  | ((request: AsyncIterable<PartialMessage<R>>) => Promise<O>)
-  | ((request: AsyncIterable<PartialMessage<R>>) => AsyncIterable<O>)
+  | ((request: AsyncIterable<Message<R>>) => Promise<O>)
+  | ((request: AsyncIterable<Message<R>>) => AsyncIterable<O>)
 
 // createInvokeFn builds an InvokeFn from a method definition and a function prototype.
 export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
@@ -39,7 +34,7 @@ export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
     dataSink: Sink<Source<Uint8Array>>,
   ) => {
     // responseSink is a Sink for response messages.
-    const responseSink = pushable<PartialMessage<O>>({
+    const responseSink = pushable<Message<O>>({
       objectMode: true,
     })
 
@@ -81,11 +76,11 @@ export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
       ) {
         const response = responseObj as AsyncIterable<O>
         return writeToPushable(
-          response as AsyncIterable<PartialMessage<O>>,
+          response as AsyncIterable<Message<O>>,
           responseSink,
         )
       } else {
-        const responsePromise = responseObj as Promise<PartialMessage<O>>
+        const responsePromise = responseObj as Promise<Message<O>>
         if (!responsePromise.then) {
           throw new Error('expected return value to be a Promise')
         }

package/srpc/message.ts

@@ -1,18 +1,16 @@
+import { MessageType, Message } from '@aptre/protobuf-es-lite'
 import type { Source } from 'it-stream-types'
-import { Message, PartialMessage, MessageType } from '@bufbuild/protobuf'
 import memoize from 'memoize-one'
 
 // MessageStream is an async iterable of partial messages.
-export type MessageStream<T extends Message<T>> = AsyncIterable<
-  PartialMessage<T>
->
+export type MessageStream<T extends Message<T>> = AsyncIterable<Message<T>>
 
 // memoProto returns a function that encodes the message and caches the result.
 export function memoProto<T extends Message<T>>(
   def: MessageType<T>,
-): (msg: PartialMessage<T>) => Uint8Array {
-  return memoize((msg: PartialMessage<T>): Uint8Array => {
-    return new def(msg).toBinary()
+): (msg: Message<T>) => Uint8Array {
+  return memoize((msg: Message<T>): Uint8Array => {
+    return def.toBinary(def.create(msg))
   })
 }
 
@@ -56,7 +54,7 @@ export function buildDecodeMessageTransform<T extends Message<T>>(
 
 // EncodeMessageTransform is a transformer that encodes messages.
 export type EncodeMessageTransform<T extends Message<T>> = (
-  source: Source<PartialMessage<T> | Array<PartialMessage<T>>>,
+  source: Source<Message<T> | Array<Message<T>>>,
 ) => AsyncIterable<Uint8Array>
 
 // buildEncodeMessageTransform builds a transformer that encodes messages.
@@ -65,15 +63,15 @@ export function buildEncodeMessageTransform<T extends Message<T>>(
 ): EncodeMessageTransform<T> {
   // encodeMessageSource marshals and async yields Messages.
   return async function* encodeMessageSource(
-    source: Source<PartialMessage<T> | Array<PartialMessage<T>>>,
+    source: Source<Message<T> | Array<Message<T>>>,
   ): AsyncIterable<Uint8Array> {
     for await (const pkt of source) {
       if (Array.isArray(pkt)) {
         for (const p of pkt) {
-          yield new def(p).toBinary()
+          yield def.toBinary(def.create(p))
         }
       } else {
-        yield new def(pkt).toBinary()
+        yield def.toBinary(def.create(pkt))
       }
     }
   }

package/srpc/pushable.ts

@@ -1,12 +1,10 @@
+import { Message } from '@aptre/protobuf-es-lite'
 import { Pushable, pushable } from 'it-pushable'
 import { Sink, Source } from 'it-stream-types'
-import { Message, PartialMessage } from '@bufbuild/protobuf'
 
-// messagePushable is a shortcut to build a pushable for partial messages.
-export function messagePushable<T extends Message<T>>(): Pushable<
-  PartialMessage<T>
-> {
-  return pushable<PartialMessage<T>>({ objectMode: true })
+// messagePushable is a shortcut to build a pushable for messages.
+export function messagePushable<T extends Message<T>>(): Pushable<T> {
+  return pushable<T>({ objectMode: true })
 }
 
 // writeToPushable writes the incoming server data to the pushable.

package/srpc/rpcproto_pb.ts

@@ -1,151 +1,54 @@
-// @generated by protoc-gen-es v1.9.0 with parameter "target=ts,ts_nocheck=false"
+// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
 
-import type {
-  BinaryReadOptions,
-  FieldList,
-  JsonReadOptions,
-  JsonValue,
-  PartialMessage,
-  PlainMessage,
-} from '@bufbuild/protobuf'
-import { Message, proto3 } from '@bufbuild/protobuf'
+import {
+  createMessageType,
+  Message,
+  MessageType,
+  PartialFieldInfo,
+} from '@aptre/protobuf-es-lite'
 
-/**
- * Packet is a message sent over a srpc packet connection.
- *
- * @generated from message srpc.Packet
- */
-export class Packet extends Message<Packet> {
-  /**
-   * Body is the packet body.
-   *
-   * @generated from oneof srpc.Packet.body
-   */
-  body:
-    | {
-        /**
-         * CallStart initiates a new call.
-         *
-         * @generated from field: srpc.CallStart call_start = 1;
-         */
-        value: CallStart
-        case: 'callStart'
-      }
-    | {
-        /**
-         * CallData is a message in a streaming RPC sequence.
-         *
-         * @generated from field: srpc.CallData call_data = 2;
-         */
-        value: CallData
-        case: 'callData'
-      }
-    | {
-        /**
-         * CallCancel cancels the call.
-         *
-         * @generated from field: bool call_cancel = 3;
-         */
-        value: boolean
-        case: 'callCancel'
-      }
-    | { case: undefined; value?: undefined } = { case: undefined }
-
-  constructor(data?: PartialMessage<Packet>) {
-    super()
-    proto3.util.initPartial(data, this)
-  }
-
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'srpc.Packet'
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: 'call_start', kind: 'message', T: CallStart, oneof: 'body' },
-    { no: 2, name: 'call_data', kind: 'message', T: CallData, oneof: 'body' },
-    {
-      no: 3,
-      name: 'call_cancel',
-      kind: 'scalar',
-      T: 8 /* ScalarType.BOOL */,
-      oneof: 'body',
-    },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): Packet {
-    return new Packet().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): Packet {
-    return new Packet().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): Packet {
-    return new Packet().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a: Packet | PlainMessage<Packet> | undefined,
-    b: Packet | PlainMessage<Packet> | undefined,
-  ): boolean {
-    return proto3.util.equals(Packet, a, b)
-  }
-}
+export const protobufPackage = 'srpc'
 
 /**
  * CallStart requests starting a new RPC call.
  *
  * @generated from message srpc.CallStart
  */
-export class CallStart extends Message<CallStart> {
+export interface CallStart extends Message<CallStart> {
   /**
    * RpcService is the service to contact.
    * Must be set.
    *
    * @generated from field: string rpc_service = 1;
    */
-  rpcService = ''
-
+  rpcService?: string
   /**
    * RpcMethod is the RPC method to call.
    * Must be set.
    *
    * @generated from field: string rpc_method = 2;
    */
-  rpcMethod = ''
-
+  rpcMethod?: string
   /**
    * Data contains the request or the first message in the stream.
    * Optional if streaming.
    *
    * @generated from field: bytes data = 3;
    */
-  data = new Uint8Array(0)
-
+  data?: Uint8Array
   /**
    * DataIsZero indicates Data is set with an empty message.
    *
    * @generated from field: bool data_is_zero = 4;
    */
-  dataIsZero = false
-
-  constructor(data?: PartialMessage<CallStart>) {
-    super()
-    proto3.util.initPartial(data, this)
-  }
+  dataIsZero?: boolean
+}
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'srpc.CallStart'
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+export const CallStart: MessageType<CallStart> = createMessageType({
+  typeName: 'srpc.CallStart',
+  fields: [
     {
       no: 1,
       name: 'rpc_service',
@@ -155,111 +58,111 @@ export class CallStart extends Message<CallStart> {
     { no: 2, name: 'rpc_method', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
     { no: 3, name: 'data', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
     { no: 4, name: 'data_is_zero', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): CallStart {
-    return new CallStart().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): CallStart {
-    return new CallStart().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): CallStart {
-    return new CallStart().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a: CallStart | PlainMessage<CallStart> | undefined,
-    b: CallStart | PlainMessage<CallStart> | undefined,
-  ): boolean {
-    return proto3.util.equals(CallStart, a, b)
-  }
-}
+  ] as readonly PartialFieldInfo[],
+  packedByDefault: true,
+})
 
 /**
  * CallData contains a message in a streaming RPC sequence.
  *
  * @generated from message srpc.CallData
  */
-export class CallData extends Message<CallData> {
+export interface CallData extends Message<CallData> {
   /**
    * Data contains the packet in the sequence.
    *
    * @generated from field: bytes data = 1;
    */
-  data = new Uint8Array(0)
-
+  data?: Uint8Array
   /**
    * DataIsZero indicates Data is set with an empty message.
    *
    * @generated from field: bool data_is_zero = 2;
    */
-  dataIsZero = false
-
+  dataIsZero?: boolean
   /**
    * Complete indicates the RPC call is completed.
    *
    * @generated from field: bool complete = 3;
    */
-  complete = false
-
+  complete?: boolean
   /**
    * Error contains any error that caused the RPC to fail.
    * If set, implies complete=true.
    *
    * @generated from field: string error = 4;
    */
-  error = ''
-
-  constructor(data?: PartialMessage<CallData>) {
-    super()
-    proto3.util.initPartial(data, this)
-  }
+  error?: string
+}
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'srpc.CallData'
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+export const CallData: MessageType<CallData> = createMessageType({
+  typeName: 'srpc.CallData',
+  fields: [
     { no: 1, name: 'data', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
     { no: 2, name: 'data_is_zero', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
     { no: 3, name: 'complete', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
     { no: 4, name: 'error', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-  ])
+  ] as readonly PartialFieldInfo[],
+  packedByDefault: true,
+})
 
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): CallData {
-    return new CallData().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): CallData {
-    return new CallData().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): CallData {
-    return new CallData().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a: CallData | PlainMessage<CallData> | undefined,
-    b: CallData | PlainMessage<CallData> | undefined,
-  ): boolean {
-    return proto3.util.equals(CallData, a, b)
-  }
+/**
+ * Packet is a message sent over a srpc packet connection.
+ *
+ * @generated from message srpc.Packet
+ */
+export interface Packet extends Message<Packet> {
+  /**
+   * Body is the packet body.
+   *
+   * @generated from oneof srpc.Packet.body
+   */
+  body?:
+    | {
+        value?: undefined
+        case: undefined
+      }
+    | {
+        /**
+         * CallStart initiates a new call.
+         *
+         * @generated from field: srpc.CallStart call_start = 1;
+         */
+        value: CallStart
+        case: 'callStart'
+      }
+    | {
+        /**
+         * CallData is a message in a streaming RPC sequence.
+         *
+         * @generated from field: srpc.CallData call_data = 2;
+         */
+        value: CallData
+        case: 'callData'
+      }
+    | {
+        /**
+         * CallCancel cancels the call.
+         *
+         * @generated from field: bool call_cancel = 3;
+         */
+        value: boolean
+        case: 'callCancel'
+      }
 }
+
+export const Packet: MessageType<Packet> = createMessageType({
+  typeName: 'srpc.Packet',
+  fields: [
+    { no: 1, name: 'call_start', kind: 'message', T: CallStart, oneof: 'body' },
+    { no: 2, name: 'call_data', kind: 'message', T: CallData, oneof: 'body' },
+    {
+      no: 3,
+      name: 'call_cancel',
+      kind: 'scalar',
+      T: 8 /* ScalarType.BOOL */,
+      oneof: 'body',
+    },
+  ] as readonly PartialFieldInfo[],
+  packedByDefault: true,
+})