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

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

@@ -0,0 +1,48 @@
+import { ConnectError } from "../connect-error.js";
+/**
+ * compressedFlag indicates that the data in a EnvelopedMessage is
+ * compressed. It has the same meaning in the gRPC-Web, gRPC-HTTP2,
+ * and Connect protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const compressedFlag = 1;
+/**
+ * Compression provides methods to compress and decompress data with
+ * a certain compression algorithm.
+ */
+export interface Compression {
+    /**
+     * The name of the compression algorithm.
+     */
+    name: string;
+    /**
+     * Compress a chunk of data.
+     */
+    compress: (bytes: Uint8Array) => Promise<Uint8Array>;
+    /**
+     * Decompress a chunk of data.
+     *
+     * A zero-length chunk is acceptable, and will return a zero-length result.
+     *
+     * Raises a ConnectError with Code.InvalidArgument if the decompressed
+     * size exceeds readMaxBytes.
+     */
+    decompress: (bytes: Uint8Array, readMaxBytes: number) => Promise<Uint8Array>;
+}
+/**
+ * Validates the request encoding and determines the accepted response encoding.
+ *
+ * Returns the request and response compression to use. If the client requested
+ * an encoding that is not available, the returned object contains an error that
+ * must be used for the response.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function compressionNegotiate(available: Compression[], requested: string | null, // e.g. the value of the Grpc-Encoding header
+accepted: string | null, // e.g. the value of the Grpc-Accept-Encoding header
+headerNameAcceptEncoding: string): {
+    request: Compression | null;
+    response: Compression | null;
+    error?: ConnectError;
+};

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

@@ -0,0 +1,71 @@
+// 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 { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+/**
+ * compressedFlag indicates that the data in a EnvelopedMessage is
+ * compressed. It has the same meaning in the gRPC-Web, gRPC-HTTP2,
+ * and Connect protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const compressedFlag = 0b00000001;
+/**
+ * Validates the request encoding and determines the accepted response encoding.
+ *
+ * Returns the request and response compression to use. If the client requested
+ * an encoding that is not available, the returned object contains an error that
+ * must be used for the response.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function compressionNegotiate(available, requested, // e.g. the value of the Grpc-Encoding header
+accepted, // e.g. the value of the Grpc-Accept-Encoding header
+headerNameAcceptEncoding) {
+    let request = null;
+    let response = null;
+    let error = undefined;
+    if (requested !== null && requested !== "identity") {
+        const found = available.find((c) => c.name === requested);
+        if (found) {
+            request = found;
+        }
+        else {
+            // To comply with https://github.com/grpc/grpc/blob/master/doc/compression.md
+            // and the Connect protocol, we return code "unimplemented" and specify
+            // acceptable compression(s).
+            const acceptable = available.map((c) => c.name).join(",");
+            error = new ConnectError(`unknown compression "${requested}": supported encodings are ${acceptable}`, Code.Unimplemented, {
+                [headerNameAcceptEncoding]: acceptable,
+            });
+        }
+    }
+    if (accepted === null || accepted === "") {
+        // Support asymmetric compression. This logic follows
+        // https://github.com/grpc/grpc/blob/master/doc/compression.md and common
+        // sense.
+        response = request;
+    }
+    else {
+        const acceptNames = accepted.split(",").map((n) => n.trim());
+        for (const name of acceptNames) {
+            const found = available.find((c) => c.name === name);
+            if (found) {
+                response = found;
+                break;
+            }
+        }
+    }
+    return { request, response, error };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/content-type-matcher.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A function that returns true if a given mime type is supported.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface ContentTypeMatcher {
+    (contentType: string | null): boolean;
+    supported: RegExp[];
+}
+/**
+ * Create a function that returns true if the given mime type is supported.
+ * A mime type is supported when one of the regular expressions match.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function contentTypeMatcher(...supported: (RegExp | Pick<ContentTypeMatcher, "supported">)[]): ContentTypeMatcher;

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

@@ -0,0 +1,40 @@
+// 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.
+const contentTypeMatcherCacheSize = 1024;
+/**
+ * Create a function that returns true if the given mime type is supported.
+ * A mime type is supported when one of the regular expressions match.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function contentTypeMatcher(...supported) {
+    const cache = new Map();
+    const source = supported.reduce((previousValue, currentValue) => previousValue.concat("supported" in currentValue ? currentValue.supported : currentValue), []);
+    function match(contentType) {
+        if (contentType === null || contentType.length == 0) {
+            return false;
+        }
+        const cached = cache.get(contentType);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const ok = source.some((re) => re.test(contentType));
+        if (cache.size < contentTypeMatcherCacheSize) {
+            cache.set(contentType, ok);
+        }
+        return ok;
+    }
+    match.supported = source;
+    return match;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/create-method-url.d.ts

@@ -0,0 +1,17 @@
+import type { MethodInfo, ServiceType } from "@bufbuild/protobuf";
+/**
+ * Create a URL for the given RPC. This simply adds the qualified
+ * service name, a slash, and the method name to the path of the given
+ * baseUrl.
+ *
+ * For example, the baseUri https://example.com and method "Say" from
+ * the service example.ElizaService results in:
+ * https://example.com/example.ElizaService/Say
+ *
+ * This format is used by the protocols Connect, gRPC and Twirp.
+ *
+ * Note that this function also accepts a protocol-relative baseUrl.
+ * If given an empty string or "/" as a baseUrl, it returns just the
+ * path.
+ */
+export declare function createMethodUrl(baseUrl: string | URL, service: ServiceType | string, method: MethodInfo | string): string;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/create-method-url.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.
+/**
+ * Create a URL for the given RPC. This simply adds the qualified
+ * service name, a slash, and the method name to the path of the given
+ * baseUrl.
+ *
+ * For example, the baseUri https://example.com and method "Say" from
+ * the service example.ElizaService results in:
+ * https://example.com/example.ElizaService/Say
+ *
+ * This format is used by the protocols Connect, gRPC and Twirp.
+ *
+ * Note that this function also accepts a protocol-relative baseUrl.
+ * If given an empty string or "/" as a baseUrl, it returns just the
+ * path.
+ */
+export function createMethodUrl(baseUrl, service, method) {
+    const s = typeof service == "string" ? service : service.typeName;
+    const m = typeof method == "string" ? method : method.name;
+    return baseUrl.toString().replace(/\/?$/, `/${s}/${m}`);
+}

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

@@ -0,0 +1,59 @@
+import type { Compression } from "./compression.js";
+/**
+ * Represents an Enveloped-Message of the Connect protocol.
+ * https://connectrpc.com/docs/protocol#streaming-rpcs
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface EnvelopedMessage {
+    /**
+     * Envelope-Flags, a set of 8 bitwise flags.
+     */
+    flags: number;
+    /**
+     * Raw data of the message that was enveloped.
+     */
+    data: Uint8Array;
+}
+/**
+ * Create a WHATWG ReadableStream of enveloped messages from a ReadableStream
+ * of bytes.
+ *
+ * Ideally, this would simply be a TransformStream, but ReadableStream.pipeThrough
+ * does not have the necessary availability at this time.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createEnvelopeReadableStream(stream: ReadableStream<Uint8Array>): ReadableStream<EnvelopedMessage>;
+/**
+ * Compress an EnvelopedMessage.
+ *
+ * Raises Internal if an enveloped message is already compressed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function envelopeCompress(envelope: EnvelopedMessage, compression: Compression | null, compressMinBytes: number): Promise<EnvelopedMessage>;
+/**
+ * Decompress an EnvelopedMessage.
+ *
+ * Raises InvalidArgument if an envelope is compressed, but compression is null.
+ *
+ * Relies on the provided Compression to raise ResourceExhausted if the
+ * *decompressed* message size is larger than readMaxBytes. If the envelope is
+ * not compressed, readMaxBytes is not honored.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function envelopeDecompress(envelope: EnvelopedMessage, compression: Compression | null, readMaxBytes: number): Promise<EnvelopedMessage>;
+/**
+ * Encode a single enveloped message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function encodeEnvelope(flags: number, data: Uint8Array): Uint8Array;
+/**
+ * Encode a set of enveloped messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function encodeEnvelopes(...envelopes: EnvelopedMessage[]): Uint8Array;

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

@@ -0,0 +1,145 @@
+// 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 { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+import { compressedFlag } from "./compression.js";
+/**
+ * Create a WHATWG ReadableStream of enveloped messages from a ReadableStream
+ * of bytes.
+ *
+ * Ideally, this would simply be a TransformStream, but ReadableStream.pipeThrough
+ * does not have the necessary availability at this time.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function createEnvelopeReadableStream(stream) {
+    let reader;
+    let buffer = new Uint8Array(0);
+    function append(chunk) {
+        const n = new Uint8Array(buffer.length + chunk.length);
+        n.set(buffer);
+        n.set(chunk, buffer.length);
+        buffer = n;
+    }
+    return new ReadableStream({
+        start() {
+            reader = stream.getReader();
+        },
+        async pull(controller) {
+            let header = undefined;
+            for (;;) {
+                if (header === undefined && buffer.byteLength >= 5) {
+                    let length = 0;
+                    for (let i = 1; i < 5; i++) {
+                        length = (length << 8) + buffer[i];
+                    }
+                    header = { flags: buffer[0], length };
+                }
+                if (header !== undefined && buffer.byteLength >= header.length + 5) {
+                    break;
+                }
+                const result = await reader.read();
+                if (result.done) {
+                    break;
+                }
+                append(result.value);
+            }
+            if (header === undefined) {
+                if (buffer.byteLength == 0) {
+                    controller.close();
+                    return;
+                }
+                controller.error(new ConnectError("premature end of stream", Code.DataLoss));
+                return;
+            }
+            const data = buffer.subarray(5, 5 + header.length);
+            buffer = buffer.subarray(5 + header.length);
+            controller.enqueue({
+                flags: header.flags,
+                data,
+            });
+        },
+    });
+}
+/**
+ * Compress an EnvelopedMessage.
+ *
+ * Raises Internal if an enveloped message is already compressed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export async function envelopeCompress(envelope, compression, compressMinBytes) {
+    let { flags, data } = envelope;
+    if ((flags & compressedFlag) === compressedFlag) {
+        throw new ConnectError("invalid envelope, already compressed", Code.Internal);
+    }
+    if (compression && data.byteLength >= compressMinBytes) {
+        data = await compression.compress(data);
+        flags = flags | compressedFlag;
+    }
+    return { data, flags };
+}
+/**
+ * Decompress an EnvelopedMessage.
+ *
+ * Raises InvalidArgument if an envelope is compressed, but compression is null.
+ *
+ * Relies on the provided Compression to raise ResourceExhausted if the
+ * *decompressed* message size is larger than readMaxBytes. If the envelope is
+ * not compressed, readMaxBytes is not honored.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export async function envelopeDecompress(envelope, compression, readMaxBytes) {
+    let { flags, data } = envelope;
+    if ((flags & compressedFlag) === compressedFlag) {
+        if (!compression) {
+            throw new ConnectError("received compressed envelope, but do not know how to decompress", Code.Internal);
+        }
+        data = await compression.decompress(data, readMaxBytes);
+        flags = flags ^ compressedFlag;
+    }
+    return { data, flags };
+}
+/**
+ * Encode a single enveloped message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function encodeEnvelope(flags, data) {
+    const bytes = new Uint8Array(data.length + 5);
+    bytes.set(data, 5);
+    const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    v.setUint8(0, flags); // first byte is flags
+    v.setUint32(1, data.length); // 4 bytes message length
+    return bytes;
+}
+/**
+ * Encode a set of enveloped messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function encodeEnvelopes(...envelopes) {
+    const len = envelopes.reduce((previousValue, currentValue) => previousValue + currentValue.data.length + 5, 0);
+    const bytes = new Uint8Array(len);
+    const v = new DataView(bytes.buffer);
+    let offset = 0;
+    for (const e of envelopes) {
+        v.setUint8(offset, e.flags); // first byte is flags
+        v.setUint32(offset + 1, e.data.length); // 4 bytes message length
+        bytes.set(e.data, offset + 5);
+        offset += e.data.length + 5;
+    }
+    return bytes;
+}

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

@@ -0,0 +1,24 @@
+export { createMethodUrl } from "./create-method-url.js";
+export type { UniversalClientFn, UniversalClientRequest, UniversalClientResponse, UniversalHandlerFn, UniversalServerRequest, UniversalServerResponse, } from "./universal.js";
+export type { Compression } from "./compression.js";
+export type { UniversalHandler } from "./universal-handler.js";
+export { createUniversalHandlerClient } from "./universal-handler-client.js";
+export { createFetchClient, createFetchHandler, universalClientRequestToFetch, universalClientResponseFromFetch, universalServerRequestFromFetch, universalServerResponseToFetch, } from "./universal-fetch.js";
+export { runUnaryCall, runStreamingCall } from "./run-call.js";
+export { createMethodSerializationLookup, createClientMethodSerializers, getJsonOptions, limitSerialization, } from "./serialization.js";
+export type { Serialization, MethodSerializationLookup, } from "./serialization.js";
+export { validateReadWriteMaxBytes } from "./limit-io.js";
+export { encodeEnvelope, encodeEnvelopes, envelopeDecompress, envelopeCompress, createEnvelopeReadableStream, } from "./envelope.js";
+export type { EnvelopedMessage } from "./envelope.js";
+export { compressedFlag, compressionNegotiate } from "./compression.js";
+export { pipe, transformCatch, transformCatchFinally, transformAppend, transformPrepend, transformReadAllBytes, transformCompressEnvelope, transformDecompressEnvelope, transformJoinEnvelopes, transformSplitEnvelope, transformSerializeEnvelope, transformParseEnvelope, pipeTo, sinkAll, sinkAllBytes, makeIterableAbortable, createWritableIterable, createAsyncIterable, readAllBytes, untilFirst, } from "./async-iterable.js";
+export type { AsyncIterableTransform, AsyncIterableSink, WritableIterable, } from "./async-iterable.js";
+export { contentTypeMatcher } from "./content-type-matcher.js";
+export type { ContentTypeMatcher } from "./content-type-matcher.js";
+export { invokeUnaryImplementation, transformInvokeImplementation, } from "./invoke-implementation.js";
+export { createLinkedAbortController, getAbortSignalReason, createDeadlineSignal, } from "./signals.js";
+export { assertByteStreamRequest, uResponseOk, uResponseNotFound, uResponseUnsupportedMediaType, uResponseMethodNotAllowed, uResponseVersionNotSupported, } from "./universal.js";
+export { validateUniversalHandlerOptions, createUniversalServiceHandlers, createUniversalMethodHandler, } from "./universal-handler.js";
+export type { UniversalHandlerOptions } from "./universal-handler.js";
+export type { ProtocolHandlerFactory } from "./protocol-handler-factory.js";
+export type { CommonTransportOptions } from "./transport-options.js";

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

@@ -0,0 +1,32 @@
+// 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 { createMethodUrl } from "./create-method-url.js";
+export { createUniversalHandlerClient } from "./universal-handler-client.js";
+export { createFetchClient, createFetchHandler, universalClientRequestToFetch, universalClientResponseFromFetch, universalServerRequestFromFetch, universalServerResponseToFetch, } from "./universal-fetch.js";
+export { runUnaryCall, runStreamingCall } from "./run-call.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 { createMethodSerializationLookup, createClientMethodSerializers, getJsonOptions, limitSerialization, } from "./serialization.js";
+export { validateReadWriteMaxBytes } from "./limit-io.js";
+export { encodeEnvelope, encodeEnvelopes, envelopeDecompress, envelopeCompress, createEnvelopeReadableStream, } from "./envelope.js";
+export { compressedFlag, compressionNegotiate } from "./compression.js";
+export { pipe, transformCatch, transformCatchFinally, transformAppend, transformPrepend, transformReadAllBytes, transformCompressEnvelope, transformDecompressEnvelope, transformJoinEnvelopes, transformSplitEnvelope, transformSerializeEnvelope, transformParseEnvelope, pipeTo, sinkAll, sinkAllBytes, makeIterableAbortable, createWritableIterable, createAsyncIterable, readAllBytes, untilFirst, } from "./async-iterable.js";
+export { contentTypeMatcher } from "./content-type-matcher.js";
+export { invokeUnaryImplementation, transformInvokeImplementation, } from "./invoke-implementation.js";
+export { createLinkedAbortController, getAbortSignalReason, createDeadlineSignal, } from "./signals.js";
+export { assertByteStreamRequest, uResponseOk, uResponseNotFound, uResponseUnsupportedMediaType, uResponseMethodNotAllowed, uResponseVersionNotSupported, } from "./universal.js";
+export { validateUniversalHandlerOptions, createUniversalServiceHandlers, createUniversalMethodHandler, } from "./universal-handler.js";

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

@@ -0,0 +1,21 @@
+import { Message, MethodKind } from "@bufbuild/protobuf";
+import type { HandlerContext, MethodImplSpec } from "../implementation.js";
+import type { AsyncIterableTransform } from "./async-iterable.js";
+import type { Interceptor } from "../interceptor.js";
+/**
+ * Invoke a user-provided implementation of a unary RPC. Returns a normalized
+ * output message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function invokeUnaryImplementation<I extends Message<I>, O extends Message<O>>(spec: MethodImplSpec<I, O> & {
+    kind: MethodKind.Unary;
+}, context: HandlerContext, input: I, interceptors: Interceptor[]): Promise<O>;
+/**
+ * Return an AsyncIterableTransform that invokes a user-provided implementation,
+ * giving it input from an asynchronous iterable, and returning its output as an
+ * asynchronous iterable.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function transformInvokeImplementation<I extends Message<I>, O extends Message<O>>(spec: MethodImplSpec<I, O>, context: HandlerContext, interceptors: Interceptor[]): AsyncIterableTransform<I, O>;