@in-human-resources/backend-proto 0.1.4 → 0.1.6

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

@@ -0,0 +1,278 @@
+// Copyright 2021-2024 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 { Message, MethodIdempotency, MethodKind, protoBase64, } from "@bufbuild/protobuf";
+import { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+import { createHandlerContext } from "../implementation.js";
+import { contentTypeStreamJson, contentTypeStreamProto, contentTypeStreamRegExp, contentTypeUnaryJson, contentTypeUnaryProto, contentTypeUnaryRegExp, parseContentType, parseEncodingQuery, } from "./content-type.js";
+import { createEndStreamSerialization, endStreamFlag } from "./end-stream.js";
+import { errorToJsonBytes } from "./error-json.js";
+import { headerContentType, headerStreamAcceptEncoding, headerStreamEncoding, headerTimeout, headerUnaryAcceptEncoding, headerUnaryContentLength, headerUnaryEncoding, } from "./headers.js";
+import { codeToHttpStatus } from "./http-status.js";
+import { parseTimeout } from "./parse-timeout.js";
+import { paramBase64, paramCompression, paramEncoding, paramMessage, } from "./query-params.js";
+import { trailerMux } from "./trailer-mux.js";
+import { requireProtocolVersionHeader, requireProtocolVersionParam, } from "./version.js";
+import { compressionNegotiate } from "../protocol/compression.js";
+import { createMethodSerializationLookup } from "../protocol/serialization.js";
+import { validateUniversalHandlerOptions } from "../protocol/universal-handler.js";
+import { assertByteStreamRequest, uResponseMethodNotAllowed, uResponseOk, uResponseUnsupportedMediaType, } from "../protocol/universal.js";
+import { createAsyncIterable, pipe, readAllBytes, transformCatchFinally, transformCompressEnvelope, transformDecompressEnvelope, transformJoinEnvelopes, transformParseEnvelope, transformPrepend, transformSerializeEnvelope, transformSplitEnvelope, untilFirst, } from "../protocol/async-iterable.js";
+import { contentTypeMatcher } from "../protocol/content-type-matcher.js";
+import { createMethodUrl } from "../protocol/create-method-url.js";
+import { invokeUnaryImplementation, transformInvokeImplementation, } from "../protocol/invoke-implementation.js";
+const protocolName = "connect";
+const methodPost = "POST";
+const methodGet = "GET";
+/**
+ * Create a factory that creates Connect handlers.
+ */
+export function createHandlerFactory(options) {
+    const opt = validateUniversalHandlerOptions(options);
+    const endStreamSerialization = createEndStreamSerialization(opt.jsonOptions);
+    function fact(spec) {
+        let h;
+        let contentTypeRegExp;
+        const serialization = createMethodSerializationLookup(spec.method, opt.binaryOptions, opt.jsonOptions, opt);
+        switch (spec.kind) {
+            case MethodKind.Unary:
+                contentTypeRegExp = contentTypeUnaryRegExp;
+                h = createUnaryHandler(opt, spec, serialization);
+                break;
+            default:
+                contentTypeRegExp = contentTypeStreamRegExp;
+                h = createStreamHandler(opt, spec, serialization, endStreamSerialization);
+                break;
+        }
+        const allowedMethods = [methodPost];
+        if (spec.method.idempotency === MethodIdempotency.NoSideEffects) {
+            allowedMethods.push(methodGet);
+        }
+        return Object.assign(h, {
+            protocolNames: [protocolName],
+            supportedContentType: contentTypeMatcher(contentTypeRegExp),
+            allowedMethods,
+            requestPath: createMethodUrl("/", spec.service, spec.method),
+            service: spec.service,
+            method: spec.method,
+        });
+    }
+    fact.protocolName = protocolName;
+    return fact;
+}
+function createUnaryHandler(opt, spec, serialization) {
+    return async function handle(req) {
+        const isGet = req.method == methodGet;
+        if (isGet && spec.method.idempotency != MethodIdempotency.NoSideEffects) {
+            return uResponseMethodNotAllowed;
+        }
+        const queryParams = new URL(req.url).searchParams;
+        const compressionRequested = isGet
+            ? queryParams.get(paramCompression)
+            : req.header.get(headerUnaryEncoding);
+        const type = isGet
+            ? parseEncodingQuery(queryParams.get(paramEncoding))
+            : parseContentType(req.header.get(headerContentType));
+        if (type == undefined || type.stream) {
+            return uResponseUnsupportedMediaType;
+        }
+        const timeout = parseTimeout(req.header.get(headerTimeout), opt.maxTimeoutMs);
+        const context = createHandlerContext(Object.assign(Object.assign({}, spec), { requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
+                [headerContentType]: type.binary
+                    ? contentTypeUnaryProto
+                    : contentTypeUnaryJson,
+            }, contextValues: req.contextValues }));
+        const compression = compressionNegotiate(opt.acceptCompression, compressionRequested, req.header.get(headerUnaryAcceptEncoding), headerUnaryAcceptEncoding);
+        let status = uResponseOk.status;
+        let body;
+        try {
+            if (opt.requireConnectProtocolHeader) {
+                if (isGet) {
+                    requireProtocolVersionParam(queryParams);
+                }
+                else {
+                    requireProtocolVersionHeader(req.header);
+                }
+            }
+            // raise compression error to serialize it as a error response
+            if (compression.error) {
+                throw compression.error;
+            }
+            // raise timeout parsing error to serialize it as a trailer status
+            if (timeout.error) {
+                throw timeout.error;
+            }
+            let reqBody;
+            if (isGet) {
+                reqBody = await readUnaryMessageFromQuery(opt.readMaxBytes, compression.request, queryParams);
+            }
+            else {
+                reqBody = await readUnaryMessageFromBody(opt.readMaxBytes, compression.request, req);
+            }
+            const input = parseUnaryMessage(spec.method, type.binary, serialization, reqBody);
+            const output = await invokeUnaryImplementation(spec, context, input, opt.interceptors);
+            body = serialization.getO(type.binary).serialize(output);
+        }
+        catch (e) {
+            let error;
+            if (e instanceof ConnectError) {
+                error = e;
+            }
+            else {
+                error = new ConnectError("internal error", Code.Internal, undefined, undefined, e);
+            }
+            status = codeToHttpStatus(error.code);
+            context.responseHeader.set(headerContentType, contentTypeUnaryJson);
+            error.metadata.forEach((value, key) => {
+                context.responseHeader.set(key, value);
+            });
+            body = errorToJsonBytes(error, opt.jsonOptions);
+        }
+        finally {
+            context.abort();
+        }
+        if (compression.response && body.byteLength >= opt.compressMinBytes) {
+            body = await compression.response.compress(body);
+            context.responseHeader.set(headerUnaryEncoding, compression.response.name);
+        }
+        const header = trailerMux(context.responseHeader, context.responseTrailer);
+        header.set(headerUnaryContentLength, body.byteLength.toString(10));
+        return {
+            status,
+            body: createAsyncIterable([body]),
+            header,
+        };
+    };
+}
+async function readUnaryMessageFromBody(readMaxBytes, compression, request) {
+    if (typeof request.body == "object" &&
+        request.body !== null &&
+        Symbol.asyncIterator in request.body) {
+        let reqBytes = await readAllBytes(request.body, readMaxBytes, request.header.get(headerUnaryContentLength));
+        if (compression) {
+            reqBytes = await compression.decompress(reqBytes, readMaxBytes);
+        }
+        return reqBytes;
+    }
+    return request.body;
+}
+async function readUnaryMessageFromQuery(readMaxBytes, compression, queryParams) {
+    var _a;
+    const base64 = queryParams.get(paramBase64);
+    const message = (_a = queryParams.get(paramMessage)) !== null && _a !== void 0 ? _a : "";
+    let decoded;
+    if (base64 === "1") {
+        decoded = protoBase64.dec(message);
+    }
+    else {
+        decoded = new TextEncoder().encode(message);
+    }
+    if (compression) {
+        decoded = await compression.decompress(decoded, readMaxBytes);
+    }
+    return decoded;
+}
+function parseUnaryMessage(method, useBinaryFormat, serialization, input) {
+    if (input instanceof Uint8Array) {
+        return serialization.getI(useBinaryFormat).parse(input);
+    }
+    if (useBinaryFormat) {
+        throw new ConnectError("received parsed JSON request body, but content-type indicates binary format", Code.Internal);
+    }
+    try {
+        return method.I.fromJson(input);
+    }
+    catch (e) {
+        throw ConnectError.from(e, Code.InvalidArgument);
+    }
+}
+function createStreamHandler(opt, spec, serialization, endStreamSerialization) {
+    return async function handle(req) {
+        assertByteStreamRequest(req);
+        const type = parseContentType(req.header.get(headerContentType));
+        if (type == undefined || !type.stream) {
+            return uResponseUnsupportedMediaType;
+        }
+        if (req.method !== methodPost) {
+            return uResponseMethodNotAllowed;
+        }
+        const timeout = parseTimeout(req.header.get(headerTimeout), opt.maxTimeoutMs);
+        const context = createHandlerContext(Object.assign(Object.assign({}, spec), { requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
+                [headerContentType]: type.binary
+                    ? contentTypeStreamProto
+                    : contentTypeStreamJson,
+            }, contextValues: req.contextValues }));
+        const compression = compressionNegotiate(opt.acceptCompression, req.header.get(headerStreamEncoding), req.header.get(headerStreamAcceptEncoding), headerStreamAcceptEncoding);
+        if (compression.response) {
+            context.responseHeader.set(headerStreamEncoding, compression.response.name);
+        }
+        // We split the pipeline into two parts: The request iterator, and the
+        // response iterator. We do this because the request iterator is responsible
+        // for parsing the request body, and we don't want write errors of the response
+        // iterator to affect the request iterator.
+        const inputIt = pipe(req.body, transformPrepend(() => {
+            if (opt.requireConnectProtocolHeader) {
+                requireProtocolVersionHeader(req.header);
+            }
+            // raise compression error to serialize it as the end stream response
+            if (compression.error)
+                throw compression.error;
+            // raise timeout parsing error to serialize it as a trailer status
+            if (timeout.error)
+                throw timeout.error;
+            return undefined;
+        }), transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression.request, opt.readMaxBytes), transformParseEnvelope(serialization.getI(type.binary), endStreamFlag));
+        const it = transformInvokeImplementation(spec, context, opt.interceptors)(inputIt)[Symbol.asyncIterator]();
+        const outputIt = pipe(
+        // We wrap the iterator in an async iterator to ensure that the
+        // abort signal is aborted when the iterator is done.
+        {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => it.next(),
+                    throw: (e) => {
+                        var _a, _b;
+                        context.abort(e);
+                        return (_b = (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, e)) !== null && _b !== void 0 ? _b : Promise.reject({ done: true });
+                    },
+                    return: (v) => {
+                        var _a, _b;
+                        context.abort();
+                        return ((_b = (_a = it.return) === null || _a === void 0 ? void 0 : _a.call(it, v)) !== null && _b !== void 0 ? _b : Promise.resolve({ done: true, value: v }));
+                    },
+                };
+            },
+        }, transformSerializeEnvelope(serialization.getO(type.binary)), transformCatchFinally((e) => {
+            context.abort();
+            const end = {
+                metadata: context.responseTrailer,
+            };
+            if (e instanceof ConnectError) {
+                end.error = e;
+            }
+            else if (e !== undefined) {
+                end.error = new ConnectError("internal error", Code.Internal, undefined, undefined, e);
+            }
+            return {
+                flags: endStreamFlag,
+                data: endStreamSerialization.serialize(end),
+            };
+        }), transformCompressEnvelope(compression.response, opt.compressMinBytes), transformJoinEnvelopes(), { propagateDownStreamError: true });
+        return Object.assign(Object.assign({}, uResponseOk), { 
+            // We wait for the first response body bytes before resolving, so that
+            // implementations have a chance to add headers before an adapter commits
+            // them to the wire.
+            body: await untilFirst(outputIt), header: context.responseHeader });
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/headers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const headerContentType = "Content-Type";
+export declare const headerUnaryContentLength = "Content-Length";
+export declare const headerUnaryEncoding = "Content-Encoding";
+export declare const headerStreamEncoding = "Connect-Content-Encoding";
+export declare const headerUnaryAcceptEncoding = "Accept-Encoding";
+export declare const headerStreamAcceptEncoding = "Connect-Accept-Encoding";
+export declare const headerTimeout = "Connect-Timeout-Ms";
+export declare const headerProtocolVersion = "Connect-Protocol-Version";
+export declare const headerUserAgent = "User-Agent";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/headers.js

@@ -0,0 +1,25 @@
+// Copyright 2021-2024 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.
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const headerContentType = "Content-Type";
+export const headerUnaryContentLength = "Content-Length";
+export const headerUnaryEncoding = "Content-Encoding";
+export const headerStreamEncoding = "Connect-Content-Encoding";
+export const headerUnaryAcceptEncoding = "Accept-Encoding";
+export const headerStreamAcceptEncoding = "Connect-Accept-Encoding";
+export const headerTimeout = "Connect-Timeout-Ms";
+export const headerProtocolVersion = "Connect-Protocol-Version";
+export const headerUserAgent = "User-Agent";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/http-status.d.ts

@@ -0,0 +1,15 @@
+import { Code } from "../code.js";
+/**
+ * Determine the Connect error code for the given HTTP status code.
+ * See https://connectrpc.com/docs/protocol/#http-to-error-code
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeFromHttpStatus(httpStatus: number): Code;
+/**
+ * Returns a HTTP status code for the given Connect code.
+ * See https://connectrpc.com/docs/protocol#error-codes
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeToHttpStatus(code: Code): number;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/http-status.js

@@ -0,0 +1,86 @@
+// Copyright 2021-2024 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 { Code } from "../code.js";
+/**
+ * Determine the Connect error code for the given HTTP status code.
+ * See https://connectrpc.com/docs/protocol/#http-to-error-code
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function codeFromHttpStatus(httpStatus) {
+    switch (httpStatus) {
+        case 400: // Bad Request
+            return Code.Internal;
+        case 401: // Unauthorized
+            return Code.Unauthenticated;
+        case 403: // Forbidden
+            return Code.PermissionDenied;
+        case 404: // Not Found
+            return Code.Unimplemented;
+        case 429: // Too Many Requests
+            return Code.Unavailable;
+        case 502: // Bad Gateway
+            return Code.Unavailable;
+        case 503: // Service Unavailable
+            return Code.Unavailable;
+        case 504: // Gateway Timeout
+            return Code.Unavailable;
+        default:
+            return Code.Unknown;
+    }
+}
+/**
+ * Returns a HTTP status code for the given Connect code.
+ * See https://connectrpc.com/docs/protocol#error-codes
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function codeToHttpStatus(code) {
+    switch (code) {
+        case Code.Canceled:
+            return 499; // Client Closed Request
+        case Code.Unknown:
+            return 500; // Internal Server Error
+        case Code.InvalidArgument:
+            return 400; // Bad Request
+        case Code.DeadlineExceeded:
+            return 504; // Gateway Timeout
+        case Code.NotFound:
+            return 404; // Not Found
+        case Code.AlreadyExists:
+            return 409; // Conflict
+        case Code.PermissionDenied:
+            return 403; // Forbidden
+        case Code.ResourceExhausted:
+            return 429; // Too Many Requests
+        case Code.FailedPrecondition:
+            return 400; // Bad Request
+        case Code.Aborted:
+            return 409; // Conflict
+        case Code.OutOfRange:
+            return 400; // Bad Request
+        case Code.Unimplemented:
+            return 501; // Not Implemented
+        case Code.Internal:
+            return 500; // Internal Server Error
+        case Code.Unavailable:
+            return 503; // Service Unavailable
+        case Code.DataLoss:
+            return 500; // Internal Server Error
+        case Code.Unauthenticated:
+            return 401; // Unauthorized
+        default:
+            return 500; // same as CodeUnknown
+    }
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/index.d.ts

@@ -0,0 +1,16 @@
+export { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+export { codeFromHttpStatus, codeToHttpStatus } from "./http-status.js";
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { endStreamToJson, endStreamFromJson, endStreamFlag, createEndStreamSerialization, } from "./end-stream.js";
+export type { EndStreamResponse } from "./end-stream.js";
+export { errorFromJson, errorFromJsonBytes, errorToJson, errorToJsonBytes, } from "./error-json.js";
+export { parseContentType, contentTypeUnaryProto, contentTypeUnaryJson, contentTypeStreamProto, contentTypeStreamJson, contentTypeRegExp, contentTypeUnaryRegExp, contentTypeStreamRegExp, } from "./content-type.js";
+export { parseTimeout } from "./parse-timeout.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { trailerMux, trailerDemux } from "./trailer-mux.js";
+export * from "./headers.js";
+export { transformConnectPostToGetRequest } from "./get-request.js";
+export { protocolVersion } from "./version.js";
+export { codeFromString } from "./code-string.js";
+export { codeToString } from "./code-string.js";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/index.js

@@ -0,0 +1,33 @@
+// Copyright 2021-2024 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.
+export { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+// All exports below are private — internal code that does not follow semantic
+// versioning.
+// We will try hard to avoid breaking changes, but if you depend on the
+// following exports, we recommend that you do so with an exact version
+// constraint (no ~ or ^).
+export { codeFromHttpStatus, codeToHttpStatus } from "./http-status.js";
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { endStreamToJson, endStreamFromJson, endStreamFlag, createEndStreamSerialization, } from "./end-stream.js";
+export { errorFromJson, errorFromJsonBytes, errorToJson, errorToJsonBytes, } from "./error-json.js";
+export { parseContentType, contentTypeUnaryProto, contentTypeUnaryJson, contentTypeStreamProto, contentTypeStreamJson, contentTypeRegExp, contentTypeUnaryRegExp, contentTypeStreamRegExp, } from "./content-type.js";
+export { parseTimeout } from "./parse-timeout.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { trailerMux, trailerDemux } from "./trailer-mux.js";
+export * from "./headers.js";
+export { transformConnectPostToGetRequest } from "./get-request.js";
+export { protocolVersion } from "./version.js";
+export { codeFromString } from "./code-string.js";
+export { codeToString } from "./code-string.js";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/parse-timeout.d.ts

@@ -0,0 +1,13 @@
+import { ConnectError } from "../connect-error.js";
+/**
+ * Parse a Connect Timeout (Deadline) header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseTimeout(value: string | null, maxTimeoutMs: number): {
+    timeoutMs?: number;
+    error?: undefined;
+} | {
+    timeoutMs?: number;
+    error: ConnectError;
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/parse-timeout.js

@@ -0,0 +1,41 @@
+// Copyright 2021-2024 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 { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+/**
+ * Parse a Connect Timeout (Deadline) header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function parseTimeout(value, maxTimeoutMs) {
+    if (value === null) {
+        return {};
+    }
+    const results = /^\d{1,10}$/.exec(value);
+    if (results === null) {
+        return {
+            error: new ConnectError(`protocol error: invalid connect timeout value: ${value}`, Code.InvalidArgument),
+        };
+    }
+    const timeoutMs = parseInt(results[0]);
+    if (timeoutMs > maxTimeoutMs) {
+        return {
+            timeoutMs: timeoutMs,
+            error: new ConnectError(`timeout ${timeoutMs}ms must be <= ${maxTimeoutMs}`, Code.InvalidArgument),
+        };
+    }
+    return {
+        timeoutMs: parseInt(results[0]),
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/query-params.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const paramConnectVersion = "connect";
+export declare const paramEncoding = "encoding";
+export declare const paramCompression = "compression";
+export declare const paramBase64 = "base64";
+export declare const paramMessage = "message";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/query-params.js

@@ -0,0 +1,21 @@
+// Copyright 2021-2024 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.
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const paramConnectVersion = "connect";
+export const paramEncoding = "encoding";
+export const paramCompression = "compression";
+export const paramBase64 = "base64";
+export const paramMessage = "message";

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

@@ -0,0 +1,19 @@
+import { MethodKind } from "@bufbuild/protobuf";
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Creates headers for a Connect request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeader(methodKind: MethodKind, useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, setUserAgent: boolean): Headers;
+/**
+ * Creates headers for a Connect request with compression.
+ *
+ * Note that we always set the Content-Encoding header for unary methods.
+ * It is up to the caller to decide whether to apply compression - and remove
+ * the header if compression is not used, for example because the payload is
+ * too small to make compression effective.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeaderWithCompression(methodKind: MethodKind, useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, acceptCompression: Compression[], sendCompression: Compression | null, setUserAgent: boolean): Headers;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/request-header.js

@@ -0,0 +1,66 @@
+// Copyright 2021-2024 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 { MethodKind } from "@bufbuild/protobuf";
+import { headerContentType, headerStreamAcceptEncoding, headerStreamEncoding, headerUnaryAcceptEncoding, headerUnaryEncoding, headerTimeout, headerProtocolVersion, headerUserAgent, } from "./headers.js";
+import { protocolVersion } from "./version.js";
+import { contentTypeStreamJson, contentTypeStreamProto, contentTypeUnaryJson, contentTypeUnaryProto, } from "./content-type.js";
+/**
+ * Creates headers for a Connect request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent) {
+    const result = new Headers(userProvidedHeaders !== null && userProvidedHeaders !== void 0 ? userProvidedHeaders : {});
+    if (timeoutMs !== undefined) {
+        result.set(headerTimeout, `${timeoutMs}`);
+    }
+    result.set(headerContentType, methodKind == MethodKind.Unary
+        ? useBinaryFormat
+            ? contentTypeUnaryProto
+            : contentTypeUnaryJson
+        : useBinaryFormat
+            ? contentTypeStreamProto
+            : contentTypeStreamJson);
+    result.set(headerProtocolVersion, protocolVersion);
+    if (setUserAgent && !result.has(headerUserAgent)) {
+        result.set(headerUserAgent, "connect-es/1.7.0");
+    }
+    return result;
+}
+/**
+ * Creates headers for a Connect request with compression.
+ *
+ * Note that we always set the Content-Encoding header for unary methods.
+ * It is up to the caller to decide whether to apply compression - and remove
+ * the header if compression is not used, for example because the payload is
+ * too small to make compression effective.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeaderWithCompression(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, acceptCompression, sendCompression, setUserAgent) {
+    const result = requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent);
+    if (sendCompression != null) {
+        const name = methodKind == MethodKind.Unary
+            ? headerUnaryEncoding
+            : headerStreamEncoding;
+        result.set(name, sendCompression.name);
+    }
+    if (acceptCompression.length > 0) {
+        const name = methodKind == MethodKind.Unary
+            ? headerUnaryAcceptEncoding
+            : headerStreamAcceptEncoding;
+        result.set(name, acceptCompression.map((c) => c.name).join(","));
+    }
+    return result;
+}