openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/content-type.js

@@ -0,0 +1,66 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// 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.
+/**
+ * Regular Expression that matches any valid Connect Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const contentTypeRegExp = /^application\/(connect\+)?(?:(json)(?:; ?charset=utf-?8)?|(proto))$/i;
+/**
+ * Regular Expression that matches a Connect unary Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const contentTypeUnaryRegExp = /^application\/(?:json(?:; ?charset=utf-?8)?|proto)$/i;
+/**
+ * Regular Expression that matches a Connect streaming Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const contentTypeStreamRegExp = /^application\/connect\+?(?:json(?:; ?charset=utf-?8)?|proto)$/i;
+export const contentTypeUnaryProto = "application/proto";
+export const contentTypeUnaryJson = "application/json";
+export const contentTypeStreamProto = "application/connect+proto";
+export const contentTypeStreamJson = "application/connect+json";
+const encodingProto = "proto";
+const encodingJson = "json";
+/**
+ * Parse a Connect Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function parseContentType(contentType) {
+    const match = contentType === null || contentType === void 0 ? void 0 : contentType.match(contentTypeRegExp);
+    if (!match) {
+        return undefined;
+    }
+    const stream = !!match[1];
+    const binary = !!match[3];
+    return { stream, binary };
+}
+/**
+ * Parse a Connect Get encoding query parameter.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function parseEncodingQuery(encoding) {
+    switch (encoding) {
+        case encodingProto:
+            return { stream: false, binary: true };
+        case encodingJson:
+            return { stream: false, binary: false };
+        default:
+            return undefined;
+    }
+}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/end-stream.d.ts

@@ -0,0 +1,44 @@
+import type { JsonObject, JsonWriteOptions } from "@bufbuild/protobuf";
+import { ConnectError } from "../connect-error.js";
+import type { Serialization } from "../protocol/serialization.js";
+/**
+ * endStreamFlag indicates that the data in a EnvelopedMessage
+ * is a EndStreamResponse of the Connect protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const endStreamFlag = 2;
+/**
+ * Represents the EndStreamResponse of the Connect protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface EndStreamResponse {
+    metadata: Headers;
+    error?: ConnectError;
+}
+/**
+ * Parse an EndStreamResponse of the Connect protocol.
+ * Throws a ConnectError on malformed input.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function endStreamFromJson(data: Uint8Array | string): EndStreamResponse;
+/**
+ * Serialize the given EndStreamResponse to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation of error details if the detail uses
+ * google.protobuf.Any.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function endStreamToJson(metadata: Headers, error: ConnectError | undefined, jsonWriteOptions: Partial<JsonWriteOptions> | undefined): JsonObject;
+/**
+ * Create a Serialization object that serializes a Connect EndStreamResponse.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createEndStreamSerialization(options: Partial<JsonWriteOptions> | undefined): Serialization<EndStreamResponse>;

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/end-stream.js

@@ -0,0 +1,131 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// 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 { errorFromJson, errorToJson } from "./error-json.js";
+import { mergeNonProtocolHeaders } from "../protocol/protocol-headers.js";
+import { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+/**
+ * endStreamFlag indicates that the data in a EnvelopedMessage
+ * is a EndStreamResponse of the Connect protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const endStreamFlag = 0b00000010;
+/**
+ * Parse an EndStreamResponse of the Connect protocol.
+ * Throws a ConnectError on malformed input.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function endStreamFromJson(data) {
+    const parseErr = new ConnectError("invalid end stream", Code.Unknown);
+    let jsonValue;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        jsonValue = JSON.parse(typeof data == "string" ? data : new TextDecoder().decode(data));
+    }
+    catch (e) {
+        throw parseErr;
+    }
+    if (typeof jsonValue != "object" ||
+        jsonValue == null ||
+        Array.isArray(jsonValue)) {
+        throw parseErr;
+    }
+    const metadata = new Headers();
+    if ("metadata" in jsonValue) {
+        if (typeof jsonValue.metadata != "object" ||
+            jsonValue.metadata == null ||
+            Array.isArray(jsonValue.metadata)) {
+            throw parseErr;
+        }
+        for (const [key, values] of Object.entries(jsonValue.metadata)) {
+            if (!Array.isArray(values) ||
+                values.some((value) => typeof value != "string")) {
+                throw parseErr;
+            }
+            for (const value of values) {
+                metadata.append(key, value);
+            }
+        }
+    }
+    const error = "error" in jsonValue && jsonValue.error != null
+        ? errorFromJson(jsonValue.error, metadata, parseErr)
+        : undefined;
+    return { metadata, error };
+}
+/**
+ * Serialize the given EndStreamResponse to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation of error details if the detail uses
+ * google.protobuf.Any.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function endStreamToJson(metadata, error, jsonWriteOptions) {
+    const es = {};
+    if (error !== undefined) {
+        es.error = errorToJson(error, jsonWriteOptions);
+        // Copy any metadata specified in the error into the target Headers.
+        // For errors parsed from the wire, we only relay the structured payload
+        // and ignore the metadata.
+        if (!error.isWireError) {
+            mergeNonProtocolHeaders(metadata, error.metadata);
+        }
+    }
+    let hasMetadata = false;
+    const md = {};
+    metadata.forEach((value, key) => {
+        hasMetadata = true;
+        md[key] = [value];
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (hasMetadata) {
+        es.metadata = md;
+    }
+    return es;
+}
+/**
+ * Create a Serialization object that serializes a Connect EndStreamResponse.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function createEndStreamSerialization(options) {
+    const textEncoder = new TextEncoder();
+    return {
+        serialize(data) {
+            try {
+                const jsonObject = endStreamToJson(data.metadata, data.error, options);
+                const jsonString = JSON.stringify(jsonObject);
+                return textEncoder.encode(jsonString);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new ConnectError(`failed to serialize EndStreamResponse: ${m}`, Code.Internal);
+            }
+        },
+        parse(data) {
+            try {
+                return endStreamFromJson(data);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new ConnectError(`failed to parse EndStreamResponse: ${m}`, Code.InvalidArgument);
+            }
+        },
+    };
+}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/error-json.d.ts

@@ -0,0 +1,36 @@
+import type { JsonObject, JsonValue, JsonWriteOptions } from "@bufbuild/protobuf";
+import { ConnectError } from "../connect-error.js";
+/**
+ * Parse a Connect error from a JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorFromJson(jsonValue: JsonValue, metadata: HeadersInit | undefined, fallback: ConnectError): ConnectError;
+/**
+ * Parse a Connect error from a serialized JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorFromJsonBytes(bytes: Uint8Array, metadata: HeadersInit | undefined, fallback: ConnectError): ConnectError;
+/**
+ * Serialize the given error to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation in the "debug" key if the detail uses
+ * google.protobuf.Any. If serialization of the "debug" value fails, it
+ * is silently disregarded.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorToJson(error: ConnectError, jsonWriteOptions: Partial<JsonWriteOptions> | undefined): JsonObject;
+/**
+ * Serialize the given error to JSON. This calls errorToJson(), but stringifies
+ * the result, and converts it into a UInt8Array.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorToJsonBytes(error: ConnectError, jsonWriteOptions: Partial<JsonWriteOptions> | undefined): Uint8Array;

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/error-json.js

@@ -0,0 +1,160 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// 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.
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { base64Decode, base64Encode } from "@bufbuild/protobuf/wire";
+import { create, toBinary, toJson } from "@bufbuild/protobuf";
+import { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+import { codeFromString, codeToString } from "./code-string.js";
+/**
+ * Parse a Connect error from a JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function errorFromJson(jsonValue, metadata, fallback) {
+    var _a;
+    if (metadata) {
+        new Headers(metadata).forEach((value, key) => fallback.metadata.append(key, value));
+    }
+    if (typeof jsonValue !== "object" ||
+        jsonValue == null ||
+        Array.isArray(jsonValue)) {
+        throw fallback;
+    }
+    let code = fallback.code;
+    if ("code" in jsonValue && typeof jsonValue.code === "string") {
+        code = (_a = codeFromString(jsonValue.code)) !== null && _a !== void 0 ? _a : code;
+    }
+    const message = jsonValue.message;
+    if (message != null && typeof message !== "string") {
+        throw fallback;
+    }
+    const error = new ConnectError(message !== null && message !== void 0 ? message : "", code, metadata);
+    error.isWireError = true;
+    if ("details" in jsonValue && Array.isArray(jsonValue.details)) {
+        for (const detail of jsonValue.details) {
+            if (detail === null ||
+                typeof detail != "object" ||
+                Array.isArray(detail) ||
+                typeof detail.type != "string" ||
+                typeof detail.value != "string") {
+                throw fallback;
+            }
+            try {
+                error.details.push({
+                    type: detail.type,
+                    value: base64Decode(detail.value),
+                    debug: detail.debug,
+                });
+            }
+            catch (e) {
+                throw fallback;
+            }
+        }
+    }
+    return error;
+}
+/**
+ * Parse a Connect error from a serialized JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function errorFromJsonBytes(bytes, metadata, fallback) {
+    let jsonValue;
+    try {
+        jsonValue = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch (e) {
+        throw fallback;
+    }
+    return errorFromJson(jsonValue, metadata, fallback);
+}
+/**
+ * Serialize the given error to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation in the "debug" key if the detail uses
+ * google.protobuf.Any. If serialization of the "debug" value fails, it
+ * is silently disregarded.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function errorToJson(error, jsonWriteOptions) {
+    const o = {
+        code: codeToString(error.code),
+    };
+    if (error.rawMessage.length > 0) {
+        o.message = error.rawMessage;
+    }
+    if (error.details.length > 0) {
+        o.details = error.details
+            .map((detail) => {
+            if ("desc" in detail) {
+                const msg = create(detail.desc, detail.value);
+                const i = {
+                    type: detail.desc.typeName,
+                    value: toBinary(detail.desc, msg),
+                };
+                try {
+                    i.debug = toJson(detail.desc, msg, jsonWriteOptions);
+                }
+                catch (e) {
+                    // We deliberately ignore errors that may occur when serializing
+                    // a message to JSON (the message contains an Any).
+                    // The rationale is that we are only trying to provide optional
+                    // debug information.
+                }
+                return i;
+            }
+            return detail;
+        })
+            .map((_a) => {
+            var { value } = _a, rest = __rest(_a, ["value"]);
+            return (Object.assign(Object.assign({}, rest), { value: base64Encode(value, "std_raw") }));
+        });
+    }
+    return o;
+}
+/**
+ * Serialize the given error to JSON. This calls errorToJson(), but stringifies
+ * the result, and converts it into a UInt8Array.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function errorToJsonBytes(error, jsonWriteOptions) {
+    const textEncoder = new TextEncoder();
+    try {
+        const jsonObject = errorToJson(error, jsonWriteOptions);
+        const jsonString = JSON.stringify(jsonObject);
+        return textEncoder.encode(jsonString);
+    }
+    catch (e) {
+        const m = e instanceof Error ? e.message : String(e);
+        throw new ConnectError(`failed to serialize Connect Error: ${m}`, Code.Internal);
+    }
+}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/get-request.d.ts

@@ -0,0 +1,6 @@
+import type { DescMessage } from "@bufbuild/protobuf";
+import type { UnaryRequest } from "../interceptor.js";
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function transformConnectPostToGetRequest<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage>(request: UnaryRequest<I, O>, message: Uint8Array, useBase64: boolean): UnaryRequest<I, O>;

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/get-request.js

@@ -0,0 +1,63 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// 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 { base64Encode } from "@bufbuild/protobuf/wire";
+import { headerContentType, headerProtocolVersion, headerUnaryAcceptEncoding, headerUnaryContentLength, headerUnaryEncoding, } from "./headers.js";
+import { protocolVersion } from "./version.js";
+const contentTypePrefix = "application/";
+function encodeMessageForUrl(message, useBase64) {
+    if (useBase64) {
+        return base64Encode(message, "url");
+    }
+    return encodeURIComponent(new TextDecoder().decode(message));
+}
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function transformConnectPostToGetRequest(request, message, useBase64) {
+    // Parameters are ordered per the Connect protocol Query-Get rule
+    // (connect, base64, compression, encoding, message).
+    let query = `?connect=v${protocolVersion}`;
+    let compressionQuery = "";
+    const compression = request.header.get(headerUnaryEncoding);
+    if (compression !== null && compression !== "identity") {
+        compressionQuery = "&compression=" + encodeURIComponent(compression);
+        // Force base64 for compressed payloads.
+        useBase64 = true;
+    }
+    if (useBase64) {
+        query += "&base64=1";
+    }
+    query += compressionQuery;
+    const contentType = request.header.get(headerContentType);
+    if ((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(contentTypePrefix)) === 0) {
+        query +=
+            "&encoding=" +
+                encodeURIComponent(contentType.slice(contentTypePrefix.length));
+    }
+    query += "&message=" + encodeMessageForUrl(message, useBase64);
+    const url = request.url + query;
+    const header = new Headers(request.header);
+    // Omit headers that are not used for unary GET requests.
+    for (const h of [
+        headerProtocolVersion,
+        headerContentType,
+        headerUnaryContentLength,
+        headerUnaryEncoding,
+        headerUnaryAcceptEncoding,
+    ]) {
+        header.delete(h);
+    }
+    return Object.assign(Object.assign({}, request), { requestMethod: "GET", url,
+        header });
+}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/handler-factory.d.ts

@@ -0,0 +1,6 @@
+import type { UniversalHandlerOptions } from "../protocol/universal-handler.js";
+import type { ProtocolHandlerFactory } from "../protocol/protocol-handler-factory.js";
+/**
+ * Create a factory that creates Connect handlers.
+ */
+export declare function createHandlerFactory(options: Partial<UniversalHandlerOptions>): ProtocolHandlerFactory;