@milaboratories/pl-client 2.16.8 → 2.16.10

package/src/proto-grpc/google/rpc/http.ts

@@ -0,0 +1,307 @@
+// @generated by protobuf-ts 2.11.1 with parameter client_generic,optimize_speed,generate_dependencies,force_server_none
+// @generated from protobuf file "google/rpc/http.proto" (package "google.rpc", syntax proto3)
+// tslint:disable
+//
+// Copyright 2025 Google LLC
+//
+// 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 { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * Represents an HTTP request.
+ *
+ * @generated from protobuf message google.rpc.HttpRequest
+ */
+export interface HttpRequest {
+    /**
+     * The HTTP request method.
+     *
+     * @generated from protobuf field: string method = 1
+     */
+    method: string;
+    /**
+     * The HTTP request URI.
+     *
+     * @generated from protobuf field: string uri = 2
+     */
+    uri: string;
+    /**
+     * The HTTP request headers. The ordering of the headers is significant.
+     * Multiple headers with the same key may present for the request.
+     *
+     * @generated from protobuf field: repeated google.rpc.HttpHeader headers = 3
+     */
+    headers: HttpHeader[];
+    /**
+     * The HTTP request body. If the body is not expected, it should be empty.
+     *
+     * @generated from protobuf field: bytes body = 4
+     */
+    body: Uint8Array;
+}
+/**
+ * Represents an HTTP response.
+ *
+ * @generated from protobuf message google.rpc.HttpResponse
+ */
+export interface HttpResponse {
+    /**
+     * The HTTP status code, such as 200 or 404.
+     *
+     * @generated from protobuf field: int32 status = 1
+     */
+    status: number;
+    /**
+     * The HTTP reason phrase, such as "OK" or "Not Found".
+     *
+     * @generated from protobuf field: string reason = 2
+     */
+    reason: string;
+    /**
+     * The HTTP response headers. The ordering of the headers is significant.
+     * Multiple headers with the same key may present for the response.
+     *
+     * @generated from protobuf field: repeated google.rpc.HttpHeader headers = 3
+     */
+    headers: HttpHeader[];
+    /**
+     * The HTTP response body. If the body is not expected, it should be empty.
+     *
+     * @generated from protobuf field: bytes body = 4
+     */
+    body: Uint8Array;
+}
+/**
+ * Represents an HTTP header.
+ *
+ * @generated from protobuf message google.rpc.HttpHeader
+ */
+export interface HttpHeader {
+    /**
+     * The HTTP header key. It is case insensitive.
+     *
+     * @generated from protobuf field: string key = 1
+     */
+    key: string;
+    /**
+     * The HTTP header value.
+     *
+     * @generated from protobuf field: string value = 2
+     */
+    value: string;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class HttpRequest$Type extends MessageType<HttpRequest> {
+    constructor() {
+        super("google.rpc.HttpRequest", [
+            { no: 1, name: "method", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "uri", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "headers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => HttpHeader },
+            { no: 4, name: "body", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<HttpRequest>): HttpRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.method = "";
+        message.uri = "";
+        message.headers = [];
+        message.body = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<HttpRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HttpRequest): HttpRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string method */ 1:
+                    message.method = reader.string();
+                    break;
+                case /* string uri */ 2:
+                    message.uri = reader.string();
+                    break;
+                case /* repeated google.rpc.HttpHeader headers */ 3:
+                    message.headers.push(HttpHeader.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* bytes body */ 4:
+                    message.body = reader.bytes();
+                    break;
+                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: HttpRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string method = 1; */
+        if (message.method !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.method);
+        /* string uri = 2; */
+        if (message.uri !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.uri);
+        /* repeated google.rpc.HttpHeader headers = 3; */
+        for (let i = 0; i < message.headers.length; i++)
+            HttpHeader.internalBinaryWrite(message.headers[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* bytes body = 4; */
+        if (message.body.length)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.body);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.HttpRequest
+ */
+export const HttpRequest = new HttpRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HttpResponse$Type extends MessageType<HttpResponse> {
+    constructor() {
+        super("google.rpc.HttpResponse", [
+            { no: 1, name: "status", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "headers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => HttpHeader },
+            { no: 4, name: "body", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<HttpResponse>): HttpResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.status = 0;
+        message.reason = "";
+        message.headers = [];
+        message.body = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<HttpResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HttpResponse): HttpResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 status */ 1:
+                    message.status = reader.int32();
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                case /* repeated google.rpc.HttpHeader headers */ 3:
+                    message.headers.push(HttpHeader.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* bytes body */ 4:
+                    message.body = reader.bytes();
+                    break;
+                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: HttpResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 status = 1; */
+        if (message.status !== 0)
+            writer.tag(1, WireType.Varint).int32(message.status);
+        /* string reason = 2; */
+        if (message.reason !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        /* repeated google.rpc.HttpHeader headers = 3; */
+        for (let i = 0; i < message.headers.length; i++)
+            HttpHeader.internalBinaryWrite(message.headers[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* bytes body = 4; */
+        if (message.body.length)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.body);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.HttpResponse
+ */
+export const HttpResponse = new HttpResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HttpHeader$Type extends MessageType<HttpHeader> {
+    constructor() {
+        super("google.rpc.HttpHeader", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<HttpHeader>): HttpHeader {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.value = "";
+        if (value !== undefined)
+            reflectionMergePartial<HttpHeader>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HttpHeader): HttpHeader {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* string value */ 2:
+                    message.value = reader.string();
+                    break;
+                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: HttpHeader, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string value = 2; */
+        if (message.value !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.value);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.HttpHeader
+ */
+export const HttpHeader = new HttpHeader$Type();

package/src/proto-grpc/google/rpc/status.ts

@@ -0,0 +1,127 @@
+// @generated by protobuf-ts 2.11.1 with parameter client_generic,optimize_speed,generate_dependencies,force_server_none
+// @generated from protobuf file "google/rpc/status.proto" (package "google.rpc", syntax proto3)
+// tslint:disable
+//
+// Copyright 2025 Google LLC
+//
+// 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 { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Any } from "../protobuf/any";
+/**
+ * The `Status` type defines a logical error model that is suitable for
+ * different programming environments, including REST APIs and RPC APIs. It is
+ * used by [gRPC](https://github.com/grpc). Each `Status` message contains
+ * three pieces of data: error code, error message, and error details.
+ *
+ * You can find out more about this error model and how to work with it in the
+ * [API Design Guide](https://cloud.google.com/apis/design/errors).
+ *
+ * @generated from protobuf message google.rpc.Status
+ */
+export interface Status {
+    /**
+     * The status code, which should be an enum value of
+     * [google.rpc.Code][google.rpc.Code].
+     *
+     * @generated from protobuf field: int32 code = 1
+     */
+    code: number;
+    /**
+     * A developer-facing error message, which should be in English. Any
+     * user-facing error message should be localized and sent in the
+     * [google.rpc.Status.details][google.rpc.Status.details] field, or localized
+     * by the client.
+     *
+     * @generated from protobuf field: string message = 2
+     */
+    message: string;
+    /**
+     * A list of messages that carry the error details.  There is a common set of
+     * message types for APIs to use.
+     *
+     * @generated from protobuf field: repeated google.protobuf.Any details = 3
+     */
+    details: Any[];
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Status$Type extends MessageType<Status> {
+    constructor() {
+        super("google.rpc.Status", [
+            { no: 1, name: "code", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "details", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Any }
+        ]);
+    }
+    create(value?: PartialMessage<Status>): Status {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.code = 0;
+        message.message = "";
+        message.details = [];
+        if (value !== undefined)
+            reflectionMergePartial<Status>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Status): Status {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 code */ 1:
+                    message.code = reader.int32();
+                    break;
+                case /* string message */ 2:
+                    message.message = reader.string();
+                    break;
+                case /* repeated google.protobuf.Any details */ 3:
+                    message.details.push(Any.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                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: Status, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 code = 1; */
+        if (message.code !== 0)
+            writer.tag(1, WireType.Varint).int32(message.code);
+        /* string message = 2; */
+        if (message.message !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.message);
+        /* repeated google.protobuf.Any details = 3; */
+        for (let i = 0; i < message.details.length; i++)
+            Any.internalBinaryWrite(message.details[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.Status
+ */
+export const Status = new Status$Type();

package/src/proto-rest/index.ts

@@ -0,0 +1,83 @@
+//
+// This file is NOT autogenerated!
+//
+// After generating new clients from openapi specifications, add client types here.
+//
+
+import type { paths as PlApiPaths } from './plapi';
+import { default as createOpenApiClient, type Middleware, type Client } from 'openapi-fetch';
+import { Dispatcher, fetch as undiciFetch } from 'undici';
+import { rethrowMeaningfulError } from '../core/errors';
+import { Code } from '../proto-grpc/google/rpc/code';
+
+export { PlApiPaths };
+export type PlRestClientType = Client<PlApiPaths>;
+
+export type RestClientConfig = {
+  hostAndPort: string;
+  ssl: boolean;
+  dispatcher: Dispatcher;
+  middlewares: Middleware[];
+}
+
+export function createClient<Paths extends {}>(opts: RestClientConfig): Client<Paths> {
+  const scheme = opts.ssl ? 'https://' : 'http://';
+  const client = createOpenApiClient<Paths>({
+    baseUrl: `${scheme}${opts.hostAndPort}`,
+    fetch: (input: Request): Promise<Response> => {
+      return undiciFetch(input.url, {
+        ...input,
+        dispatcher: opts.dispatcher,
+      });
+    },
+  });
+  client.use(errorHandlerMiddleware(), ...opts.middlewares);
+  return client;
+}
+
+export type ErrorResponse = {
+  code: Code,
+  message: string,
+  details: any[],
+}
+export async function parseResponseError(response: Response): Promise<{
+  error?: ErrorResponse | string,
+  origBody?: string,
+}>{
+  if (response.status < 400) {
+    return {};
+  }
+
+  let error: any = await response.clone().text();
+  const origBody = error;
+  try {
+    error = JSON.parse(error) as ErrorResponse;
+  } catch {
+  }
+  return {
+    error: error,
+    origBody
+  };
+}
+
+/**
+ * Parses all API responses and thrown error in case of error response.
+ * Allows all callers to not bother about .error response field checking.
+ */
+function errorHandlerMiddleware(): Middleware {
+  return {
+    onResponse: async ({ request: _request, response, options: _options }) => {
+      const respErr = await parseResponseError(response);
+      if (!respErr.error) {
+        const { body, ...resOptions } = response;
+        return new Response(body, { ...resOptions, status: response.status });
+      }
+
+      if (typeof respErr.error === 'string') {
+        throw new Error(respErr.error);
+      }
+
+      rethrowMeaningfulError(respErr.error);
+    },
+  };
+}