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

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/context-values.js

@@ -0,0 +1,37 @@
+// 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.
+/**
+ * createContextValues creates a new ContextValues.
+ */
+export function createContextValues() {
+    return {
+        get(key) {
+            return key.id in this ? this[key.id] : key.defaultValue;
+        },
+        set(key, value) {
+            this[key.id] = value;
+            return this;
+        },
+        delete(key) {
+            delete this[key.id];
+            return this;
+        },
+    };
+}
+/**
+ * createContextKey creates a new ContextKey.
+ */
+export function createContextKey(defaultValue, options) {
+    return { id: Symbol(options === null || options === void 0 ? void 0 : options.description), defaultValue };
+}

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

@@ -0,0 +1,45 @@
+/**
+ * CORS prevents rogue scripts in a web browser from making arbitrary requests
+ * to other web servers.
+ *
+ * This object provides helpful constants to configure CORS middleware for
+ * cross-domain requests with the protocols supported by Connect.
+ *
+ * Make sure to add application-specific headers that your application
+ * uses as well.
+ */
+export declare const cors: {
+    /**
+     * Request methods that scripts running in the browser are permitted to use.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these headers fields must be included in the preflight response header
+     * Access-Control-Allow-Methods.
+     */
+    allowedMethods: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running in the browser are permitted to send.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in the preflight response header
+     * Access-Control-Allow-Headers.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * may send.
+     */
+    allowedHeaders: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running the browser are permitted to see.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in header Access-Control-Expose-Headers
+     * of the actual response.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * should see. If your application uses trailers, they will be sent as header
+     * fields with a `Trailer-` prefix for Connect unary RPCs - make sure to
+     * expose them as well if you want them to be visible in all supported
+     * protocols.
+     */
+    exposedHeaders: ReadonlyArray<string>;
+};

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

@@ -0,0 +1,79 @@
+// 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 * as connect from "./protocol-connect/headers.js";
+import * as grpc from "./protocol-grpc/headers.js";
+import * as grpcWeb from "./protocol-grpc-web/headers.js";
+/**
+ * CORS prevents rogue scripts in a web browser from making arbitrary requests
+ * to other web servers.
+ *
+ * This object provides helpful constants to configure CORS middleware for
+ * cross-domain requests with the protocols supported by Connect.
+ *
+ * Make sure to add application-specific headers that your application
+ * uses as well.
+ */
+export const cors = {
+    /**
+     * Request methods that scripts running in the browser are permitted to use.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these headers fields must be included in the preflight response header
+     * Access-Control-Allow-Methods.
+     */
+    allowedMethods: ["POST", "GET"],
+    /**
+     * Header fields that scripts running in the browser are permitted to send.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in the preflight response header
+     * Access-Control-Allow-Headers.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * may send.
+     */
+    allowedHeaders: [
+        connect.headerContentType,
+        connect.headerProtocolVersion,
+        connect.headerTimeout,
+        connect.headerStreamEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerStreamAcceptEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerUnaryEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerUnaryAcceptEncoding, // Unused in web browsers, but added for future-proofing
+        grpc.headerMessageType, // Unused in web browsers, but added for future-proofing
+        grpcWeb.headerXGrpcWeb,
+        grpcWeb.headerXUserAgent,
+        grpcWeb.headerTimeout,
+    ],
+    /**
+     * Header fields that scripts running the browser are permitted to see.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in header Access-Control-Expose-Headers
+     * of the actual response.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * should see. If your application uses trailers, they will be sent as header
+     * fields with a `Trailer-` prefix for Connect unary RPCs - make sure to
+     * expose them as well if you want them to be visible in all supported
+     * protocols.
+     */
+    exposedHeaders: [
+        grpcWeb.headerGrpcStatus, // Crucial for gRPC-web
+        grpcWeb.headerGrpcMessage, // Crucial for gRPC-web
+        grpcWeb.headerStatusDetailsBin, // Error details in gRPC, gRPC-web
+        connect.headerUnaryEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerStreamEncoding, // Unused in web browsers, but added for future-proofing
+    ],
+};

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

@@ -0,0 +1,36 @@
+import type { Message, BinaryReadOptions, MessageType } from "@bufbuild/protobuf";
+/**
+ * Encode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function accepts raw binary data from a buffer, a string
+ * with UTF-8 text, or a protobuf message. It encodes the input
+ * with unpadded base64 and returns a string that can be used for
+ * a header whose name ends with `-bin`.
+ */
+export declare function encodeBinaryHeader(value: Uint8Array | ArrayBufferLike | Message | string): string;
+/**
+ * Decode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function returns the raw binary data from a header whose
+ * name ends with `-bin`. If given a message type in the second
+ * argument, it deserializes a protobuf message. To decode a value
+ * that contains unicode text, pass the raw binary data returned
+ * from this function through TextDecoder.decode.
+ *
+ * Note that duplicate header names may have their values joined
+ * with a `,` as the delimiter, so you most likely will want to
+ * split by `,` first.
+ *
+ * If this function detects invalid base-64 encoding, or invalid
+ * binary message data, it throws a ConnectError with code
+ * DataLoss.
+ */
+export declare function decodeBinaryHeader(value: string): Uint8Array;
+export declare function decodeBinaryHeader<T extends Message<T>>(value: string, type: MessageType<T>, options?: Partial<BinaryReadOptions>): T;
+/**
+ * Merge two or more Headers objects by appending all fields from
+ * all inputs to a new Headers object.
+ */
+export declare function appendHeaders(...headers: Headers[]): Headers;

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

@@ -0,0 +1,63 @@
+// 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 { protoBase64 } from "@bufbuild/protobuf";
+import { ConnectError } from "./connect-error.js";
+import { Code } from "./code.js";
+/**
+ * Encode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function accepts raw binary data from a buffer, a string
+ * with UTF-8 text, or a protobuf message. It encodes the input
+ * with unpadded base64 and returns a string that can be used for
+ * a header whose name ends with `-bin`.
+ */
+export function encodeBinaryHeader(value) {
+    let bytes;
+    if (typeof value == "object" && "getType" in value) {
+        bytes = value.toBinary();
+    }
+    else if (typeof value == "string") {
+        bytes = new TextEncoder().encode(value);
+    }
+    else {
+        bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+    }
+    return protoBase64.enc(bytes).replace(/=+$/, "");
+}
+export function decodeBinaryHeader(value, type, options) {
+    try {
+        const bytes = protoBase64.dec(value);
+        if (type) {
+            return type.fromBinary(bytes, options);
+        }
+        return bytes;
+    }
+    catch (e) {
+        throw ConnectError.from(e, Code.DataLoss);
+    }
+}
+/**
+ * Merge two or more Headers objects by appending all fields from
+ * all inputs to a new Headers object.
+ */
+export function appendHeaders(...headers) {
+    const h = new Headers();
+    for (const e of headers) {
+        e.forEach((value, key) => {
+            h.append(key, value);
+        });
+    }
+    return h;
+}

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

@@ -0,0 +1,165 @@
+import type { AnyMessage, Message, MessageType, MethodIdempotency, MethodInfo, PartialMessage, ServiceType } from "@bufbuild/protobuf";
+import { MethodKind } from "@bufbuild/protobuf";
+import type { ContextValues } from "./context-values.js";
+/**
+ * ServiceImpl is the interface of the implementation of a service.
+ */
+export type ServiceImpl<T extends ServiceType> = {
+    [P in keyof T["methods"]]: MethodImpl<T["methods"][P]>;
+};
+/**
+ * MethodImpl is the signature of the implementation of an RPC.
+ */
+export type MethodImpl<M extends MI> = M extends MI<infer I, infer O, MethodKind.Unary> ? UnaryImpl<I, O> : M extends MI<infer I, infer O, MethodKind.ServerStreaming> ? ServerStreamingImpl<I, O> : M extends MI<infer I, infer O, MethodKind.ClientStreaming> ? ClientStreamingImpl<I, O> : M extends MI<infer I, infer O, MethodKind.BiDiStreaming> ? BiDiStreamingImpl<I, O> : never;
+interface MI<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage, K extends MethodKind = MethodKind> {
+    readonly kind: K;
+    readonly name: string;
+    readonly I: MessageType<I>;
+    readonly O: MessageType<O>;
+    readonly idempotency?: MethodIdempotency;
+}
+/**
+ * Context for an RPC on the server. Every RPC implementation can accept a
+ * HandlerContext as an argument to gain access to headers and service metadata.
+ */
+export interface HandlerContext {
+    /**
+     * Metadata for the method being called.
+     */
+    readonly method: MethodInfo;
+    /**
+     * Metadata for the service being called.
+     */
+    readonly service: ServiceType;
+    /**
+     * An AbortSignal that is aborted when the connection with the client is closed
+     * or when the deadline is reached.
+     *
+     * The signal can be used to automatically cancel downstream calls.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * If the current request has a timeout, this function returns the remaining
+     * time.
+     */
+    readonly timeoutMs: () => number | undefined;
+    /**
+     * HTTP method of incoming request, usually "POST", but "GET" in the case of
+     * Connect Get.
+     */
+    readonly requestMethod: string;
+    /**
+     * Incoming request headers.
+     */
+    readonly requestHeader: Headers;
+    /**
+     * Outgoing response headers.
+     *
+     * For methods that return a stream, response headers must be set before
+     * yielding the first response message.
+     */
+    readonly responseHeader: Headers;
+    /**
+     * Outgoing response trailers.
+     */
+    readonly responseTrailer: Headers;
+    /**
+     * Name of the RPC protocol in use; one of "connect", "grpc" or "grpc-web".
+     */
+    readonly protocolName: string;
+    /**
+     * Per RPC context values that can be used to pass data to handlers.
+     */
+    readonly values: ContextValues;
+    /**
+     * The URL received by the server.
+     */
+    readonly url: string;
+}
+/**
+ * Options for creating a HandlerContext.
+ */
+interface HandlerContextInit {
+    service: ServiceType;
+    method: MethodInfo;
+    protocolName: string;
+    requestMethod: string;
+    url: string;
+    timeoutMs?: number;
+    shutdownSignal?: AbortSignal;
+    requestSignal?: AbortSignal;
+    requestHeader?: HeadersInit;
+    responseHeader?: HeadersInit;
+    responseTrailer?: HeadersInit;
+    contextValues?: ContextValues;
+}
+interface HandlerContextController extends HandlerContext {
+    abort(reason?: unknown): void;
+}
+/**
+ * Create a new HandlerContext.
+ *
+ * The context is usually automatically created by handlers, but if a service
+ * implementation is used in unit tests, this function can be used to create
+ * a context.
+ */
+export declare function createHandlerContext(init: HandlerContextInit): HandlerContextController;
+/**
+ * UnaryImp is the signature of the implementation of a unary RPC.
+ */
+export type UnaryImpl<I extends Message<I>, O extends Message<O>> = (request: I, context: HandlerContext) => Promise<O | PartialMessage<O>> | O | PartialMessage<O>;
+/**
+ * ClientStreamingImpl is the signature of the implementation of a
+ * client-streaming RPC.
+ */
+export type ClientStreamingImpl<I extends Message<I>, O extends Message<O>> = (requests: AsyncIterable<I>, context: HandlerContext) => Promise<O | PartialMessage<O>>;
+/**
+ * ServerStreamingImpl is the signature of the implementation of a
+ * server-streaming RPC.
+ */
+export type ServerStreamingImpl<I extends Message<I>, O extends Message<O>> = (request: I, context: HandlerContext) => AsyncIterable<O | PartialMessage<O>>;
+/**
+ * BiDiStreamingImpl is the signature of the implementation of a bi-di
+ * streaming RPC.
+ */
+export type BiDiStreamingImpl<I extends Message<I>, O extends Message<O>> = (requests: AsyncIterable<I>, context: HandlerContext) => AsyncIterable<O | PartialMessage<O>>;
+/**
+ * Wraps a user-provided implementation along with service and method
+ * metadata in a discriminated union type.
+ */
+export type MethodImplSpec<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = {
+    service: ServiceType;
+    method: MethodInfo<I, O>;
+} & ({
+    kind: MethodKind.Unary;
+    impl: UnaryImpl<I, O>;
+} | {
+    kind: MethodKind.ServerStreaming;
+    impl: ServerStreamingImpl<I, O>;
+} | {
+    kind: MethodKind.ClientStreaming;
+    impl: ClientStreamingImpl<I, O>;
+} | {
+    kind: MethodKind.BiDiStreaming;
+    impl: BiDiStreamingImpl<I, O>;
+});
+/**
+ * Wraps a user-provided service implementation and provides metadata.
+ */
+export type ServiceImplSpec = {
+    service: ServiceType;
+    methods: {
+        [key: string]: MethodImplSpec;
+    };
+};
+/**
+ * Create an MethodImplSpec - a user-provided implementation for a method,
+ * wrapped in a discriminated union type along with service and method metadata.
+ */
+export declare function createMethodImplSpec<M extends MethodInfo>(service: ServiceType, method: M, impl: MethodImpl<M>): MethodImplSpec;
+/**
+ * Create an ServiceImplSpec - a user-provided service implementation wrapped
+ * with metadata.
+ */
+export declare function createServiceImplSpec<T extends ServiceType>(service: T, impl: Partial<ServiceImpl<T>>): ServiceImplSpec;
+export {};

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

@@ -0,0 +1,75 @@
+// 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 { ConnectError } from "./connect-error.js";
+import { Code } from "./code.js";
+import { createDeadlineSignal, createLinkedAbortController, } from "./protocol/signals.js";
+import { createContextValues } from "./context-values.js";
+/**
+ * Create a new HandlerContext.
+ *
+ * The context is usually automatically created by handlers, but if a service
+ * implementation is used in unit tests, this function can be used to create
+ * a context.
+ */
+export function createHandlerContext(init) {
+    var _a;
+    let timeoutMs;
+    if (init.timeoutMs !== undefined) {
+        const date = new Date(Date.now() + init.timeoutMs);
+        timeoutMs = () => date.getTime() - Date.now();
+    }
+    else {
+        timeoutMs = () => undefined;
+    }
+    const deadline = createDeadlineSignal(init.timeoutMs);
+    const abortController = createLinkedAbortController(deadline.signal, init.requestSignal, init.shutdownSignal);
+    return Object.assign(Object.assign({}, init), { signal: abortController.signal, timeoutMs, requestHeader: new Headers(init.requestHeader), responseHeader: new Headers(init.responseHeader), responseTrailer: new Headers(init.responseTrailer), abort(reason) {
+            deadline.cleanup();
+            abortController.abort(reason);
+        }, values: (_a = init.contextValues) !== null && _a !== void 0 ? _a : createContextValues() });
+}
+/**
+ * Create an MethodImplSpec - a user-provided implementation for a method,
+ * wrapped in a discriminated union type along with service and method metadata.
+ */
+export function createMethodImplSpec(service, method, impl) {
+    return {
+        kind: method.kind,
+        service,
+        method,
+        impl,
+    };
+}
+/**
+ * Create an ServiceImplSpec - a user-provided service implementation wrapped
+ * with metadata.
+ */
+export function createServiceImplSpec(service, impl) {
+    const s = { service, methods: {} };
+    for (const [localName, methodInfo] of Object.entries(service.methods)) {
+        let fn = impl[localName];
+        if (typeof fn == "function") {
+            fn = fn.bind(impl);
+        }
+        else {
+            const message = `${service.typeName}.${methodInfo.name} is not implemented`;
+            fn = function unimplemented() {
+                throw new ConnectError(message, Code.Unimplemented);
+            };
+        }
+        s.methods[localName] = createMethodImplSpec(service, methodInfo, fn);
+    }
+    return s;
+}

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

@@ -0,0 +1,22 @@
+export { ConnectError } from "./connect-error.js";
+export { Code } from "./code.js";
+export { encodeBinaryHeader, decodeBinaryHeader, appendHeaders, } from "./http-headers.js";
+export { createCallbackClient } from "./callback-client.js";
+export type { CallbackClient } from "./callback-client.js";
+export { createClient, createPromiseClient } from "./promise-client.js";
+export type { Client, PromiseClient } from "./promise-client.js";
+export type { CallOptions } from "./call-options.js";
+export type { Transport } from "./transport.js";
+export type { Interceptor, UnaryRequest, UnaryResponse, StreamRequest, StreamResponse, } from "./interceptor.js";
+export type { ServiceImpl, MethodImpl, HandlerContext, } from "./implementation.js";
+export { createConnectRouter } from "./router.js";
+export type { ConnectRouter, ConnectRouterOptions } from "./router.js";
+export { createHandlerContext } from "./implementation.js";
+export { cors } from "./cors.js";
+export { createContextKey, createContextValues } from "./context-values.js";
+export type { ContextKey, ContextValues } from "./context-values.js";
+export { makeAnyClient } from "./any-client.js";
+export type { AnyClient } from "./any-client.js";
+export { createServiceImplSpec, createMethodImplSpec, } from "./implementation.js";
+export type { ServiceImplSpec, MethodImplSpec } from "./implementation.js";
+export { createRouterTransport } from "./router-transport.js";

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

@@ -0,0 +1,27 @@
+// 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 { ConnectError } from "./connect-error.js";
+export { Code } from "./code.js";
+export { encodeBinaryHeader, decodeBinaryHeader, appendHeaders, } from "./http-headers.js";
+export { createCallbackClient } from "./callback-client.js";
+export { createClient, createPromiseClient } from "./promise-client.js";
+export { createConnectRouter } from "./router.js";
+export { createHandlerContext } from "./implementation.js";
+export { cors } from "./cors.js";
+export { createContextKey, createContextValues } from "./context-values.js";
+// Symbols above should be relevant to end users.
+// Symbols below should only be relevant for other libraries.
+export { makeAnyClient } from "./any-client.js";
+export { createServiceImplSpec, createMethodImplSpec, } from "./implementation.js";
+export { createRouterTransport } from "./router-transport.js";