@milaboratories/pl-client 2.16.12 → 2.16.13

package/src/proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.ts

@@ -39,8 +39,11 @@ import { Status } from "../../../../googleapis/googleapis/google/rpc/status";
  *   - client reads server responses for each messages sent. Client can batch
  *     writes and reads: e.g. send 3 messages, read 2 responses, send one
  *     more, read 2;
- *   - to finish communication client sends 'commit' message and reads last
+ *   - to finish communication client sends 'commit' or 'discard' message and reads last
  *     response;
+ *   - to make server interrupt communication, client sends 'stream_close' message and reads to the last
+ *     server response. This allows graceful stream close, waiting for all queued server responses
+ *     to be sent before closing the stream.
  *
  * Detailed description of the process.
  *
@@ -117,6 +120,10 @@ import { Status } from "../../../../googleapis/googleapis/google/rpc/status";
  *    - server stops reading client stream and does the commit/discard action.
  *    - once transaction is closed, server sends the result to client and
  *      closes server stream.
+ *    - client stream reading may be interrupted by special 'stream_close' message, which
+ *      causes transaction automatic discard and does not produce additional reply message.
+ *      This 'stream_close' message also does not require any 'request_id' value and does not
+ *      produce any response from server side.
  *
  * At this point the transaction over gRPC is considered as finalized, all
  * local IDs generated within the transaction are no longer valid.
@@ -171,6 +178,22 @@ export interface TxAPI_ClientMessage {
          * @generated from protobuf field: MiLaboratories.PL.API.TxAPI.Discard.Request tx_discard = 13
          */
         txDiscard: TxAPI_Discard_Request; // discard the transaction and close the stream
+    } | {
+        oneofKind: "streamClose";
+        /**
+         * Interrupt the transaction network stream on server side.
+         *
+         * This allows to gracefully close network connection and discard the associated transaction,
+         * ensuring all pending server responses are sent to the client before closing.
+         * We use this in RO transactions to imitate the feature of 'half-open' connection
+         * available in pure gRPC, when we work with WebSockets.
+         * Pure gRPC uses 'end of client messages stream' as a criteria for graceful discard.
+         * Pure WebSocket does not allow this, breaking entire connection at once. stream_close helps to get
+         * behaviour as we have for gRPC.
+         *
+         * @generated from protobuf field: MiLaboratories.PL.API.TxAPI.CloseStream.Request stream_close = 14
+         */
+        streamClose: TxAPI_CloseStream_Request; // ask server to send all pending messages and close the stream
     } | {
         oneofKind: "resourceCreateRoot";
         /**
@@ -535,6 +558,12 @@ export interface TxAPI_ServerMessage {
          * @generated from protobuf field: MiLaboratories.PL.API.TxAPI.Discard.Response tx_discard = 13
          */
         txDiscard: TxAPI_Discard_Response;
+    } | {
+        oneofKind: "streamClose";
+        /**
+         * @generated from protobuf field: MiLaboratories.PL.API.TxAPI.CloseStream.Response stream_close = 14
+         */
+        streamClose: TxAPI_CloseStream_Response;
     } | {
         oneofKind: "resourceCreateRoot";
         /**
@@ -979,6 +1008,21 @@ export interface TxAPI_Discard_Request {
  */
 export interface TxAPI_Discard_Response {
 }
+/**
+ * @generated from protobuf message MiLaboratories.PL.API.TxAPI.CloseStream
+ */
+export interface TxAPI_CloseStream {
+}
+/**
+ * @generated from protobuf message MiLaboratories.PL.API.TxAPI.CloseStream.Request
+ */
+export interface TxAPI_CloseStream_Request {
+}
+/**
+ * @generated from protobuf message MiLaboratories.PL.API.TxAPI.CloseStream.Response
+ */
+export interface TxAPI_CloseStream_Response {
+}
 /**
  * @generated from protobuf message MiLaboratories.PL.API.TxAPI.Sync
  */
@@ -3152,6 +3196,7 @@ class TxAPI_ClientMessage$Type extends MessageType<TxAPI_ClientMessage> {
             { no: 11, name: "tx_open", kind: "message", oneof: "request", T: () => TxAPI_Open_Request },
             { no: 12, name: "tx_commit", kind: "message", oneof: "request", T: () => TxAPI_Commit_Request },
             { no: 13, name: "tx_discard", kind: "message", oneof: "request", T: () => TxAPI_Discard_Request },
+            { no: 14, name: "stream_close", kind: "message", oneof: "request", T: () => TxAPI_CloseStream_Request },
             { no: 58, name: "resource_create_root", kind: "message", oneof: "request", T: () => ResourceAPI_CreateRoot_Request },
             { no: 57, name: "resource_remove", kind: "message", oneof: "request", T: () => ResourceAPI_Remove_Request },
             { no: 51, name: "resource_create_struct", kind: "message", oneof: "request", T: () => ResourceAPI_CreateStruct_Request },
@@ -3242,6 +3287,12 @@ class TxAPI_ClientMessage$Type extends MessageType<TxAPI_ClientMessage> {
                         txDiscard: TxAPI_Discard_Request.internalBinaryRead(reader, reader.uint32(), options, (message.request as any).txDiscard)
                     };
                     break;
+                case /* MiLaboratories.PL.API.TxAPI.CloseStream.Request stream_close */ 14:
+                    message.request = {
+                        oneofKind: "streamClose",
+                        streamClose: TxAPI_CloseStream_Request.internalBinaryRead(reader, reader.uint32(), options, (message.request as any).streamClose)
+                    };
+                    break;
                 case /* MiLaboratories.PL.API.ResourceAPI.CreateRoot.Request resource_create_root */ 58:
                     message.request = {
                         oneofKind: "resourceCreateRoot",
@@ -3590,6 +3641,9 @@ class TxAPI_ClientMessage$Type extends MessageType<TxAPI_ClientMessage> {
         /* MiLaboratories.PL.API.TxAPI.Discard.Request tx_discard = 13; */
         if (message.request.oneofKind === "txDiscard")
             TxAPI_Discard_Request.internalBinaryWrite(message.request.txDiscard, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* MiLaboratories.PL.API.TxAPI.CloseStream.Request stream_close = 14; */
+        if (message.request.oneofKind === "streamClose")
+            TxAPI_CloseStream_Request.internalBinaryWrite(message.request.streamClose, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
         /* MiLaboratories.PL.API.ResourceAPI.CreateStruct.Request resource_create_struct = 51; */
         if (message.request.oneofKind === "resourceCreateStruct")
             ResourceAPI_CreateStruct_Request.internalBinaryWrite(message.request.resourceCreateStruct, writer.tag(51, WireType.LengthDelimited).fork(), options).join();
@@ -3771,6 +3825,7 @@ class TxAPI_ServerMessage$Type extends MessageType<TxAPI_ServerMessage> {
             { no: 11, name: "tx_open", kind: "message", oneof: "response", T: () => TxAPI_Open_Response },
             { no: 12, name: "tx_commit", kind: "message", oneof: "response", T: () => TxAPI_Commit_Response },
             { no: 13, name: "tx_discard", kind: "message", oneof: "response", T: () => TxAPI_Discard_Response },
+            { no: 14, name: "stream_close", kind: "message", oneof: "response", T: () => TxAPI_CloseStream_Response },
             { no: 58, name: "resource_create_root", kind: "message", oneof: "response", T: () => ResourceAPI_CreateRoot_Response },
             { no: 57, name: "resource_remove", kind: "message", oneof: "response", T: () => ResourceAPI_Remove_Response },
             { no: 51, name: "resource_create_struct", kind: "message", oneof: "response", T: () => ResourceAPI_CreateStruct_Response },
@@ -3865,6 +3920,12 @@ class TxAPI_ServerMessage$Type extends MessageType<TxAPI_ServerMessage> {
                         txDiscard: TxAPI_Discard_Response.internalBinaryRead(reader, reader.uint32(), options, (message.response as any).txDiscard)
                     };
                     break;
+                case /* MiLaboratories.PL.API.TxAPI.CloseStream.Response stream_close */ 14:
+                    message.response = {
+                        oneofKind: "streamClose",
+                        streamClose: TxAPI_CloseStream_Response.internalBinaryRead(reader, reader.uint32(), options, (message.response as any).streamClose)
+                    };
+                    break;
                 case /* MiLaboratories.PL.API.ResourceAPI.CreateRoot.Response resource_create_root */ 58:
                     message.response = {
                         oneofKind: "resourceCreateRoot",
@@ -4222,6 +4283,9 @@ class TxAPI_ServerMessage$Type extends MessageType<TxAPI_ServerMessage> {
         /* MiLaboratories.PL.API.TxAPI.Discard.Response tx_discard = 13; */
         if (message.response.oneofKind === "txDiscard")
             TxAPI_Discard_Response.internalBinaryWrite(message.response.txDiscard, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* MiLaboratories.PL.API.TxAPI.CloseStream.Response stream_close = 14; */
+        if (message.response.oneofKind === "streamClose")
+            TxAPI_CloseStream_Response.internalBinaryWrite(message.response.streamClose, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
         /* MiLaboratories.PL.API.ResourceAPI.CreateStruct.Response resource_create_struct = 51; */
         if (message.response.oneofKind === "resourceCreateStruct")
             ResourceAPI_CreateStruct_Response.internalBinaryWrite(message.response.resourceCreateStruct, writer.tag(51, WireType.LengthDelimited).fork(), options).join();
@@ -4842,6 +4906,120 @@ class TxAPI_Discard_Response$Type extends MessageType<TxAPI_Discard_Response> {
  */
 export const TxAPI_Discard_Response = new TxAPI_Discard_Response$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class TxAPI_CloseStream$Type extends MessageType<TxAPI_CloseStream> {
+    constructor() {
+        super("MiLaboratories.PL.API.TxAPI.CloseStream", []);
+    }
+    create(value?: PartialMessage<TxAPI_CloseStream>): TxAPI_CloseStream {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<TxAPI_CloseStream>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TxAPI_CloseStream): TxAPI_CloseStream {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: TxAPI_CloseStream, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.TxAPI.CloseStream
+ */
+export const TxAPI_CloseStream = new TxAPI_CloseStream$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TxAPI_CloseStream_Request$Type extends MessageType<TxAPI_CloseStream_Request> {
+    constructor() {
+        super("MiLaboratories.PL.API.TxAPI.CloseStream.Request", []);
+    }
+    create(value?: PartialMessage<TxAPI_CloseStream_Request>): TxAPI_CloseStream_Request {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<TxAPI_CloseStream_Request>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TxAPI_CloseStream_Request): TxAPI_CloseStream_Request {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: TxAPI_CloseStream_Request, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.TxAPI.CloseStream.Request
+ */
+export const TxAPI_CloseStream_Request = new TxAPI_CloseStream_Request$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TxAPI_CloseStream_Response$Type extends MessageType<TxAPI_CloseStream_Response> {
+    constructor() {
+        super("MiLaboratories.PL.API.TxAPI.CloseStream.Response", []);
+    }
+    create(value?: PartialMessage<TxAPI_CloseStream_Response>): TxAPI_CloseStream_Response {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<TxAPI_CloseStream_Response>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TxAPI_CloseStream_Response): TxAPI_CloseStream_Response {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: TxAPI_CloseStream_Response, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.TxAPI.CloseStream.Response
+ */
+export const TxAPI_CloseStream_Response = new TxAPI_CloseStream_Response$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class TxAPI_Sync$Type extends MessageType<TxAPI_Sync> {
     constructor() {
         super("MiLaboratories.PL.API.TxAPI.Sync", []);

package/src/proto-rest/index.ts

@@ -25,9 +25,24 @@ export function createClient<Paths extends {}>(opts: RestClientConfig): Client<P
   const client = createOpenApiClient<Paths>({
     baseUrl: `${scheme}${opts.hostAndPort}`,
     fetch: (input: Request): Promise<Response> => {
-      return undiciFetch(input.url, {
-        ...input,
+      // If body has already been consumed, clone the request
+      const request = input.bodyUsed ? input.clone() : input;
+
+      return undiciFetch(request.url, {
+        body: request.body,
+        cache: request.cache,
+        credentials: request.credentials,
         dispatcher: opts.dispatcher,
+        duplex: request.duplex,
+        headers: request.headers,
+        integrity: request.integrity,
+        keepalive: request.keepalive,
+        method: request.method,
+        mode: request.mode,
+        redirect: request.redirect,
+        referrer: request.referrer,
+        referrerPolicy: request.referrerPolicy,
+        signal: request.signal,
       });
     },
   });