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

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/transport.js

@@ -0,0 +1,238 @@
+"use strict";
+// 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.
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransport = createTransport;
+const validate_trailer_js_1 = require("../protocol-grpc/validate-trailer.js");
+const request_header_js_1 = require("./request-header.js");
+const validate_response_js_1 = require("./validate-response.js");
+const trailer_js_1 = require("./trailer.js");
+const code_js_1 = require("../code.js");
+const connect_error_js_1 = require("../connect-error.js");
+const async_iterable_js_1 = require("../protocol/async-iterable.js");
+const create_method_url_js_1 = require("../protocol/create-method-url.js");
+const run_call_js_1 = require("../protocol/run-call.js");
+const serialization_js_1 = require("../protocol/serialization.js");
+const context_values_js_1 = require("../context-values.js");
+const headers_js_1 = require("./headers.js");
+/**
+ * Create a Transport for the gRPC-web protocol.
+ */
+function createTransport(opt) {
+    return {
+        async unary(service, method, signal, timeoutMs, header, message, contextValues) {
+            const serialization = (0, serialization_js_1.createMethodSerializationLookup)(method, opt.binaryOptions, opt.jsonOptions, opt);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return await (0, run_call_js_1.runUnaryCall)({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: false,
+                    service,
+                    method,
+                    url: (0, create_method_url_js_1.createMethodUrl)(opt.baseUrl, service, method),
+                    init: {},
+                    header: (0, request_header_js_1.requestHeaderWithCompression)(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : (0, context_values_js_1.createContextValues)(),
+                    message,
+                },
+                next: async (req) => {
+                    const uRes = await opt.httpClient({
+                        url: req.url,
+                        method: "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body: (0, async_iterable_js_1.pipe)((0, async_iterable_js_1.createAsyncIterable)([req.message]), (0, async_iterable_js_1.transformSerializeEnvelope)(serialization.getI(opt.useBinaryFormat)), (0, async_iterable_js_1.transformCompressEnvelope)(opt.sendCompression, opt.compressMinBytes), (0, async_iterable_js_1.transformJoinEnvelopes)(), {
+                            propagateDownStreamError: true,
+                        }),
+                    });
+                    const { compression, headerError } = (0, validate_response_js_1.validateResponseWithCompression)(opt.acceptCompression, uRes.status, uRes.header);
+                    const { trailer, message } = await (0, async_iterable_js_1.pipeTo)(uRes.body, (0, async_iterable_js_1.transformSplitEnvelope)(opt.readMaxBytes), (0, async_iterable_js_1.transformDecompressEnvelope)(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), (0, async_iterable_js_1.transformParseEnvelope)(serialization.getO(opt.useBinaryFormat), trailer_js_1.trailerFlag, (0, trailer_js_1.createTrailerSerialization)()), async (iterable) => {
+                        var _a, e_1, _b, _c;
+                        let message;
+                        let trailer;
+                        try {
+                            for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = await iterable_1.next(), _a = iterable_1_1.done, !_a; _d = true) {
+                                _c = iterable_1_1.value;
+                                _d = false;
+                                const env = _c;
+                                if (env.end) {
+                                    if (trailer !== undefined) {
+                                        throw new connect_error_js_1.ConnectError("protocol error: received extra trailer", code_js_1.Code.Unimplemented);
+                                    }
+                                    trailer = env.value;
+                                }
+                                else {
+                                    if (message !== undefined) {
+                                        throw new connect_error_js_1.ConnectError("protocol error: received extra output message for unary method", code_js_1.Code.Unimplemented);
+                                    }
+                                    message = env.value;
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = iterable_1.return)) await _b.call(iterable_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        return { trailer, message };
+                    }, {
+                        propagateDownStreamError: false,
+                    });
+                    if (trailer === undefined) {
+                        if (headerError != undefined) {
+                            throw headerError;
+                        }
+                        throw new connect_error_js_1.ConnectError("protocol error: missing trailer", uRes.header.has(headers_js_1.headerGrpcStatus)
+                            ? code_js_1.Code.Unimplemented
+                            : code_js_1.Code.Unknown);
+                    }
+                    (0, validate_trailer_js_1.validateTrailer)(trailer, uRes.header);
+                    if (message === undefined) {
+                        throw new connect_error_js_1.ConnectError("protocol error: missing output message for unary method", trailer.has(headers_js_1.headerGrpcStatus) ? code_js_1.Code.Unimplemented : code_js_1.Code.Unknown);
+                    }
+                    return {
+                        stream: false,
+                        service,
+                        method,
+                        header: uRes.header,
+                        message,
+                        trailer,
+                    };
+                },
+            });
+        },
+        async stream(service, method, signal, timeoutMs, header, input, contextValues) {
+            const serialization = (0, serialization_js_1.createMethodSerializationLookup)(method, opt.binaryOptions, opt.jsonOptions, opt);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return (0, run_call_js_1.runStreamingCall)({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: true,
+                    service,
+                    method,
+                    url: (0, create_method_url_js_1.createMethodUrl)(opt.baseUrl, service, method),
+                    init: {
+                        method: "POST",
+                        redirect: "error",
+                        mode: "cors",
+                    },
+                    header: (0, request_header_js_1.requestHeaderWithCompression)(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : (0, context_values_js_1.createContextValues)(),
+                    message: input,
+                },
+                next: async (req) => {
+                    const uRes = await opt.httpClient({
+                        url: req.url,
+                        method: "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body: (0, async_iterable_js_1.pipe)(req.message, (0, async_iterable_js_1.transformSerializeEnvelope)(serialization.getI(opt.useBinaryFormat)), (0, async_iterable_js_1.transformCompressEnvelope)(opt.sendCompression, opt.compressMinBytes), (0, async_iterable_js_1.transformJoinEnvelopes)(), { propagateDownStreamError: true }),
+                    });
+                    const { compression, foundStatus, headerError } = (0, validate_response_js_1.validateResponseWithCompression)(opt.acceptCompression, uRes.status, uRes.header);
+                    if (headerError) {
+                        throw headerError;
+                    }
+                    const res = Object.assign(Object.assign({}, req), { header: uRes.header, trailer: new Headers(), message: (0, async_iterable_js_1.pipe)(uRes.body, (0, async_iterable_js_1.transformSplitEnvelope)(opt.readMaxBytes), (0, async_iterable_js_1.transformDecompressEnvelope)(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), (0, async_iterable_js_1.transformParseEnvelope)(serialization.getO(opt.useBinaryFormat), trailer_js_1.trailerFlag, (0, trailer_js_1.createTrailerSerialization)()), function (iterable) {
+                            return __asyncGenerator(this, arguments, function* () {
+                                var _a, e_2, _b, _c;
+                                if (foundStatus) {
+                                    // A grpc-status: 0 response header was present. This is a "trailers-only"
+                                    // response (a response without a body and no trailers).
+                                    //
+                                    // The spec seems to disallow a trailers-only response for status 0 - we are
+                                    // lenient and only verify that the body is empty.
+                                    //
+                                    // > [...] Trailers-Only is permitted for calls that produce an immediate error.
+                                    // See https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
+                                    const r = yield __await(iterable[Symbol.asyncIterator]().next());
+                                    if (r.done !== true) {
+                                        throw new connect_error_js_1.ConnectError("protocol error: extra data for trailers-only", code_js_1.Code.InvalidArgument);
+                                    }
+                                    return yield __await(void 0);
+                                }
+                                let trailerReceived = false;
+                                try {
+                                    for (var _d = true, iterable_2 = __asyncValues(iterable), iterable_2_1; iterable_2_1 = yield __await(iterable_2.next()), _a = iterable_2_1.done, !_a; _d = true) {
+                                        _c = iterable_2_1.value;
+                                        _d = false;
+                                        const chunk = _c;
+                                        if (chunk.end) {
+                                            if (trailerReceived) {
+                                                throw new connect_error_js_1.ConnectError("protocol error: received extra trailer", code_js_1.Code.InvalidArgument);
+                                            }
+                                            trailerReceived = true;
+                                            (0, validate_trailer_js_1.validateTrailer)(chunk.value, uRes.header);
+                                            chunk.value.forEach((value, key) => res.trailer.set(key, value));
+                                            continue;
+                                        }
+                                        if (trailerReceived) {
+                                            throw new connect_error_js_1.ConnectError("protocol error: received extra message after trailer", code_js_1.Code.InvalidArgument);
+                                        }
+                                        yield yield __await(chunk.value);
+                                    }
+                                }
+                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                finally {
+                                    try {
+                                        if (!_d && !_a && (_b = iterable_2.return)) yield __await(_b.call(iterable_2));
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                }
+                                if (!trailerReceived) {
+                                    throw new connect_error_js_1.ConnectError("protocol error: missing trailer", code_js_1.Code.Internal);
+                                }
+                            });
+                        }, { propagateDownStreamError: true }) });
+                    return res;
+                },
+            });
+        },
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/validate-response.d.ts

@@ -0,0 +1,34 @@
+import { ConnectError } from "../connect-error.js";
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ *
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponse(status: number, headers: Headers): {
+    foundStatus: boolean;
+    headerError?: ConnectError;
+};
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponseWithCompression(acceptCompression: Compression[], status: number, headers: Headers): {
+    foundStatus: boolean;
+    compression: Compression | undefined;
+    headerError?: ConnectError;
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/validate-response.js

@@ -0,0 +1,73 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateResponse = validateResponse;
+exports.validateResponseWithCompression = validateResponseWithCompression;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+const headers_js_1 = require("./headers.js");
+const http_status_js_1 = require("../protocol-grpc/http-status.js");
+const trailer_status_js_1 = require("../protocol-grpc/trailer-status.js");
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ *
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateResponse(status, headers) {
+    var _a;
+    // For compatibility with the `grpc-web` package, we treat all HTTP status
+    // codes in the 200 range as valid, not just HTTP 200.
+    if (status >= 200 && status < 300) {
+        return {
+            foundStatus: headers.has(headers_js_1.headerGrpcStatus),
+            headerError: (0, trailer_status_js_1.findTrailerError)(headers),
+        };
+    }
+    throw new connect_error_js_1.ConnectError(decodeURIComponent((_a = headers.get(headers_js_1.headerGrpcMessage)) !== null && _a !== void 0 ? _a : `HTTP ${status}`), (0, http_status_js_1.codeFromHttpStatus)(status), headers);
+}
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateResponseWithCompression(acceptCompression, status, headers) {
+    const { foundStatus, headerError } = validateResponse(status, headers);
+    let compression;
+    const encoding = headers.get(headers_js_1.headerEncoding);
+    if (encoding !== null && encoding.toLowerCase() !== "identity") {
+        compression = acceptCompression.find((c) => c.name === encoding);
+        if (!compression) {
+            throw new connect_error_js_1.ConnectError(`unsupported response encoding "${encoding}"`, code_js_1.Code.Internal, headers);
+        }
+    }
+    return {
+        foundStatus,
+        compression,
+        headerError,
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/router-transport.d.ts

@@ -0,0 +1,13 @@
+import type { CommonTransportOptions } from "./protocol/transport-options.js";
+import type { ConnectRouter, ConnectRouterOptions } from "./router.js";
+/**
+ * Creates a Transport that routes requests to the configured router. Useful for testing
+ * and calling services running in the same process.
+ *
+ * This can be used to test both client logic by using this to stub/mock the backend,
+ * and to test server logic by using this to run without needing to spin up a server.
+ */
+export declare function createRouterTransport(routes: (router: ConnectRouter) => void, options?: {
+    transport?: Partial<CommonTransportOptions>;
+    router?: ConnectRouterOptions;
+}): import("./transport.js").Transport;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/router-transport.js

@@ -0,0 +1,32 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouterTransport = createRouterTransport;
+const transport_js_1 = require("./protocol-connect/transport.js");
+const universal_handler_client_js_1 = require("./protocol/universal-handler-client.js");
+const router_js_1 = require("./router.js");
+/**
+ * Creates a Transport that routes requests to the configured router. Useful for testing
+ * and calling services running in the same process.
+ *
+ * This can be used to test both client logic by using this to stub/mock the backend,
+ * and to test server logic by using this to run without needing to spin up a server.
+ */
+function createRouterTransport(routes, options) {
+    var _a, _b;
+    const router = (0, router_js_1.createConnectRouter)(Object.assign(Object.assign({}, ((_a = options === null || options === void 0 ? void 0 : options.router) !== null && _a !== void 0 ? _a : {})), { connect: true }));
+    routes(router);
+    return (0, transport_js_1.createTransport)(Object.assign({ httpClient: (0, universal_handler_client_js_1.createUniversalHandlerClient)(router.handlers), baseUrl: "https://in-memory", useBinaryFormat: true, interceptors: [], acceptCompression: [], sendCompression: null, compressMinBytes: Number.MAX_SAFE_INTEGER, readMaxBytes: Number.MAX_SAFE_INTEGER, writeMaxBytes: Number.MAX_SAFE_INTEGER }, ((_b = options === null || options === void 0 ? void 0 : options.transport) !== null && _b !== void 0 ? _b : {})));
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/router.d.ts

@@ -0,0 +1,88 @@
+import type { MethodInfo, ServiceType } from "@bufbuild/protobuf";
+import type { MethodImpl, ServiceImpl } from "./implementation.js";
+import type { UniversalHandler, UniversalHandlerOptions } from "./protocol/universal-handler.js";
+import type { MethodType } from "./method-type.js";
+/**
+ * ConnectRouter is your single registration point for RPCs.
+ *
+ * Create a file `connect.ts` with a default export such as this:
+ *
+ * ```ts
+ * import {ConnectRouter} from "@connectrpc/connect";
+ *
+ * export default (router: ConnectRouter) => {
+ *   router.service(ElizaService, {});
+ * }
+ * ```
+ *
+ * The pass this function to adapters and plugins, for example
+ * from @connectrpc/connect-node, or from @connectrpc/connect-fastify.
+ */
+export interface ConnectRouter {
+    readonly handlers: UniversalHandler[];
+    /**
+     * Register a service implementation, and object with methods for the
+     * individual RPCs.
+     *
+     * You don't have to implement all RPCs of a service. If you omit a method,
+     * the router adds a method that responds with an error code `unimplemented`.
+     */
+    service<T extends ServiceType>(service: T, implementation: Partial<ServiceImpl<T>>, options?: Partial<UniversalHandlerOptions>): this;
+    /**
+     * Register a single RPC implementation.
+     */
+    rpc<M extends MethodInfo>(service: ServiceType, method: M, impl: MethodImpl<M>, options?: Partial<UniversalHandlerOptions>): this;
+    /**
+     * Register a single RPC implementation for a method type.
+     *
+     * @private This is an experimental API. Please do not rely on it yet.
+     */
+    rpc<M extends MethodType>(method: M, impl: MethodImpl<M>, options?: Partial<UniversalHandlerOptions>): this;
+}
+/**
+ * Options for a ConnectRouter. By default, all three protocols gRPC, gRPC-web,
+ * and Connect are enabled.
+ */
+export interface ConnectRouterOptions extends Partial<UniversalHandlerOptions> {
+    /**
+     * Enable the gRPC protocol and make your API available to all gRPC clients
+     * for various platforms and languages. See https://grpc.io/
+     *
+     * The protocol is enabled by default. Set this option to `false` to disable
+     * it, but mind that at least one protocol must be enabled.
+     *
+     * Note that gRPC is typically served with TLS over HTTP/2 and requires access
+     * to HTTP trailers.
+     */
+    grpc?: boolean;
+    /**
+     * Enable the gRPC-web protocol and make your API available to all gRPC-web
+     * clients. gRPC-web is commonly used in web browsers, but there are client
+     * implementations for other platforms as well, for example in Dart, Kotlin,
+     * and Swift. See https://github.com/grpc/grpc-web
+     *
+     * The protocol is enabled by default. Set this option to `false` to disable
+     * it, but mind that at least one protocol must be enabled.
+     *
+     * gRPC-web works over HTTP 1.1 or HTTP/2 and does not require access to HTTP
+     * trailers. Note that bidi streaming requires HTTP/2, and web browsers may
+     * not support all streaming types.
+     */
+    grpcWeb?: boolean;
+    /**
+     * Enable the Connect protocol and make your API available to all Connect
+     * clients, but also for a simple call with curl. See https://connectrpc.com/
+     *
+     * The protocol is enabled by default. Set this option to `false` to disable
+     * it, but mind that at least one protocol must be enabled.
+     *
+     * Connect works over HTTP 1.1 or HTTP/2 and does not require access to HTTP
+     * trailers. Note that bidi streaming requires HTTP/2, and web browsers may
+     * not support all streaming types.
+     */
+    connect?: boolean;
+}
+/**
+ * Create a new ConnectRouter.
+ */
+export declare function createConnectRouter(routerOptions?: ConnectRouterOptions): ConnectRouter;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/router.js

@@ -0,0 +1,83 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnectRouter = createConnectRouter;
+const connect_error_js_1 = require("./connect-error.js");
+const code_js_1 = require("./code.js");
+const implementation_js_1 = require("./implementation.js");
+const handler_factory_js_1 = require("./protocol-grpc-web/handler-factory.js");
+const handler_factory_js_2 = require("./protocol-grpc/handler-factory.js");
+const handler_factory_js_3 = require("./protocol-connect/handler-factory.js");
+const universal_handler_js_1 = require("./protocol/universal-handler.js");
+/**
+ * Create a new ConnectRouter.
+ */
+function createConnectRouter(routerOptions) {
+    const base = whichProtocols(routerOptions);
+    const handlers = [];
+    return {
+        handlers,
+        service(service, implementation, options) {
+            const { protocols } = whichProtocols(options, base);
+            handlers.push(...(0, universal_handler_js_1.createUniversalServiceHandlers)((0, implementation_js_1.createServiceImplSpec)(service, implementation), protocols));
+            return this;
+        },
+        rpc(serviceOrMethod, methodOrImpl, implementationOrOptions, options) {
+            let service;
+            let method;
+            let impl;
+            let opt;
+            if ("typeName" in serviceOrMethod) {
+                service = serviceOrMethod;
+                method = methodOrImpl;
+                impl = implementationOrOptions;
+                opt = options;
+            }
+            else {
+                service = Object.assign(Object.assign({}, serviceOrMethod.service), { methods: {} });
+                method = serviceOrMethod;
+                impl = methodOrImpl;
+                opt = implementationOrOptions;
+            }
+            const { protocols } = whichProtocols(opt, base);
+            handlers.push((0, universal_handler_js_1.createUniversalMethodHandler)((0, implementation_js_1.createMethodImplSpec)(service, method, impl), protocols));
+            return this;
+        },
+    };
+}
+function whichProtocols(options, base) {
+    if (base && !options) {
+        return base;
+    }
+    const opt = base
+        ? Object.assign(Object.assign({}, (0, universal_handler_js_1.validateUniversalHandlerOptions)(base.options)), options) : Object.assign(Object.assign({}, options), (0, universal_handler_js_1.validateUniversalHandlerOptions)(options !== null && options !== void 0 ? options : {}));
+    const protocols = [];
+    if ((options === null || options === void 0 ? void 0 : options.grpc) !== false) {
+        protocols.push((0, handler_factory_js_2.createHandlerFactory)(opt));
+    }
+    if ((options === null || options === void 0 ? void 0 : options.grpcWeb) !== false) {
+        protocols.push((0, handler_factory_js_1.createHandlerFactory)(opt));
+    }
+    if ((options === null || options === void 0 ? void 0 : options.connect) !== false) {
+        protocols.push((0, handler_factory_js_3.createHandlerFactory)(opt));
+    }
+    if (protocols.length === 0) {
+        throw new connect_error_js_1.ConnectError("cannot create handler, all protocols are disabled", code_js_1.Code.InvalidArgument);
+    }
+    return {
+        options: opt,
+        protocols,
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/transport.d.ts

@@ -0,0 +1,20 @@
+import type { AnyMessage, Message, MethodInfo, PartialMessage, ServiceType } from "@bufbuild/protobuf";
+import type { StreamResponse, UnaryResponse } from "./interceptor.js";
+import type { ContextValues } from "./context-values.js";
+/**
+ * Transport represents the underlying transport for a client.
+ * A transport implements a protocol, such as Connect or gRPC-web, and allows
+ * for the concrete clients to be independent of the protocol.
+ */
+export interface Transport {
+    /**
+     * Call a unary RPC - a method that takes a single input message, and
+     * responds with a single output message.
+     */
+    unary<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage>(service: ServiceType, method: MethodInfo<I, O>, signal: AbortSignal | undefined, timeoutMs: number | undefined, header: HeadersInit | undefined, input: PartialMessage<I>, contextValues?: ContextValues): Promise<UnaryResponse<I, O>>;
+    /**
+     * Call a streaming RPC - a method that takes zero or more input messages,
+     * and responds with zero or more output messages.
+     */
+    stream<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage>(service: ServiceType, method: MethodInfo<I, O>, signal: AbortSignal | undefined, timeoutMs: number | undefined, header: HeadersInit | undefined, input: AsyncIterable<PartialMessage<I>>, contextValues?: ContextValues): Promise<StreamResponse<I, O>>;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/transport.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/any-client.d.ts

@@ -0,0 +1,22 @@
+import type { ServiceType, MethodInfo } from "@bufbuild/protobuf";
+/**
+ * AnyClient is an arbitrary service client with any method signature.
+ *
+ * It usually has methods for all methods defined for a service, but may
+ * omit some, for example because it's transport does not support streaming.
+ */
+export type AnyClient = Record<string, AnyClientMethod>;
+type AnyClientMethod = (...args: any[]) => any;
+type CreateAnyClientMethod = (method: MethodInfo & {
+    localName: string;
+    service: ServiceType;
+}) => AnyClientMethod | null;
+/**
+ * Create any client for the given service.
+ *
+ * The given createMethod function is called for each method definition
+ * of the service. The function it returns is added to the client object
+ * as a method.
+ */
+export declare function makeAnyClient(service: ServiceType, createMethod: CreateAnyClientMethod): AnyClient;
+export {};