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

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

@@ -0,0 +1,246 @@
+// 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 __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]); }
+};
+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 __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+import { Message, MethodKind } from "@bufbuild/protobuf";
+import { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+import { normalize, normalizeIterable } from "./normalize.js";
+import { applyInterceptors } 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 async function invokeUnaryImplementation(spec, context, input, interceptors) {
+    const anyFn = async (req) => {
+        return {
+            message: normalize(spec.method.O, await spec.impl(req.message, Object.assign(Object.assign({}, context), { service: req.service, method: req.method, requestHeader: req.header, values: req.contextValues, signal: req.signal }))),
+            stream: false,
+            service: req.service,
+            method: req.method,
+            header: context.responseHeader,
+            trailer: context.responseTrailer,
+        };
+    };
+    const next = applyInterceptors(anyFn, interceptors);
+    const { message } = await next({
+        init: {
+            method: context.requestMethod,
+        },
+        message: input,
+        url: context.url,
+        signal: context.signal,
+        service: spec.service,
+        method: spec.method,
+        header: context.requestHeader,
+        contextValues: context.values,
+        stream: false,
+    });
+    return message;
+}
+/**
+ * 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 function transformInvokeImplementation(spec, context, interceptors) {
+    switch (spec.kind) {
+        case MethodKind.Unary:
+            return function unary(input) {
+                return __asyncGenerator(this, arguments, function* unary_1() {
+                    const inputIt = input[Symbol.asyncIterator]();
+                    const input1 = yield __await(inputIt.next());
+                    if (input1.done === true) {
+                        throw new ConnectError("protocol error: missing input message for unary method", Code.Unimplemented);
+                    }
+                    const anyFn = async (req) => {
+                        return {
+                            message: normalize(spec.method.O, await spec.impl(req.message, Object.assign(Object.assign({}, context), { service: req.service, method: req.method, requestHeader: req.header, values: req.contextValues, signal: req.signal }))),
+                            stream: false,
+                            service: req.service,
+                            method: req.method,
+                            header: context.responseHeader,
+                            trailer: context.responseTrailer,
+                        };
+                    };
+                    const next = applyInterceptors(anyFn, interceptors);
+                    const { message, header, trailer } = yield __await(next({
+                        init: {
+                            method: context.requestMethod,
+                        },
+                        message: input1.value,
+                        url: context.url,
+                        signal: context.signal,
+                        service: spec.service,
+                        method: spec.method,
+                        header: context.requestHeader,
+                        contextValues: context.values,
+                        stream: false,
+                    }));
+                    copyHeaders(header, context.responseHeader);
+                    copyHeaders(trailer, context.responseTrailer);
+                    yield yield __await(message);
+                    const input2 = yield __await(inputIt.next());
+                    if (input2.done !== true) {
+                        throw new ConnectError("protocol error: received extra input message for unary method", Code.Unimplemented);
+                    }
+                });
+            };
+        case MethodKind.ServerStreaming: {
+            return function serverStreaming(input) {
+                return __asyncGenerator(this, arguments, function* serverStreaming_1() {
+                    const inputIt = input[Symbol.asyncIterator]();
+                    const input1 = yield __await(inputIt.next());
+                    if (input1.done === true) {
+                        throw new ConnectError("protocol error: missing input message for server-streaming method", Code.Unimplemented);
+                    }
+                    const anyFn = async (req) => {
+                        return {
+                            message: normalizeIterable(spec.method.O, spec.impl(req.message, Object.assign(Object.assign({}, context), { service: req.service, method: req.method, requestHeader: req.header, values: req.contextValues, signal: req.signal }))),
+                            stream: true,
+                            service: req.service,
+                            method: req.method,
+                            header: context.responseHeader,
+                            trailer: context.responseTrailer,
+                        };
+                    };
+                    const next = applyInterceptors(anyFn, interceptors);
+                    const { message, header, trailer } = yield __await(next({
+                        init: {
+                            method: context.requestMethod,
+                        },
+                        message: input1.value,
+                        url: context.url,
+                        signal: context.signal,
+                        service: spec.service,
+                        method: spec.method,
+                        header: context.requestHeader,
+                        contextValues: context.values,
+                        stream: false,
+                    }));
+                    copyHeaders(header, context.responseHeader);
+                    copyHeaders(trailer, context.responseTrailer);
+                    yield __await(yield* __asyncDelegator(__asyncValues(message)));
+                    const input2 = yield __await(inputIt.next());
+                    if (input2.done !== true) {
+                        throw new ConnectError("protocol error: received extra input message for server-streaming method", Code.Unimplemented);
+                    }
+                });
+            };
+        }
+        case MethodKind.ClientStreaming: {
+            return function clientStreaming(input) {
+                return __asyncGenerator(this, arguments, function* clientStreaming_1() {
+                    const anyFn = async (req) => {
+                        return {
+                            message: normalize(spec.method.O, await spec.impl(req.message, Object.assign(Object.assign({}, context), { service: req.service, method: req.method, requestHeader: req.header, values: req.contextValues, signal: req.signal }))),
+                            stream: false,
+                            service: req.service,
+                            method: req.method,
+                            header: context.responseHeader,
+                            trailer: context.responseTrailer,
+                        };
+                    };
+                    const next = applyInterceptors(anyFn, interceptors);
+                    const { message, header, trailer } = yield __await(next({
+                        init: {
+                            method: context.requestMethod,
+                        },
+                        message: input,
+                        url: context.url,
+                        signal: context.signal,
+                        service: spec.service,
+                        method: spec.method,
+                        header: context.requestHeader,
+                        contextValues: context.values,
+                        stream: true,
+                    }));
+                    copyHeaders(header, context.responseHeader);
+                    copyHeaders(trailer, context.responseTrailer);
+                    yield yield __await(message);
+                });
+            };
+        }
+        case MethodKind.BiDiStreaming:
+            return function biDiStreaming(input) {
+                return __asyncGenerator(this, arguments, function* biDiStreaming_1() {
+                    const anyFn = async (req) => {
+                        return {
+                            message: normalizeIterable(spec.method.O, spec.impl(req.message, Object.assign(Object.assign({}, context), { service: req.service, method: req.method, requestHeader: req.header, values: req.contextValues, signal: req.signal }))),
+                            stream: true,
+                            service: req.service,
+                            method: req.method,
+                            header: context.responseHeader,
+                            trailer: context.responseTrailer,
+                        };
+                    };
+                    const next = applyInterceptors(anyFn, interceptors);
+                    const { message, header, trailer } = yield __await(next({
+                        init: {
+                            method: context.requestMethod,
+                        },
+                        message: input,
+                        url: context.url,
+                        signal: context.signal,
+                        service: spec.service,
+                        method: spec.method,
+                        header: context.requestHeader,
+                        contextValues: context.values,
+                        stream: true,
+                    }));
+                    copyHeaders(header, context.responseHeader);
+                    copyHeaders(trailer, context.responseTrailer);
+                    yield __await(yield* __asyncDelegator(__asyncValues(message)));
+                });
+            };
+    }
+}
+function copyHeaders(from, to) {
+    if (from === to) {
+        return;
+    }
+    to.forEach((_, key) => {
+        to.delete(key);
+    });
+    from.forEach((value, key) => {
+        to.set(key, value);
+    });
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Asserts that the options writeMaxBytes, readMaxBytes, and compressMinBytes
+ * are within sane limits, and returns default values where no value is
+ * provided.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateReadWriteMaxBytes(readMaxBytes: number | undefined, writeMaxBytes: number | undefined, compressMinBytes: number | undefined): {
+    readMaxBytes: number;
+    writeMaxBytes: number;
+    compressMinBytes: number;
+};
+/**
+ * Raise an error ResourceExhausted if more than writeMaxByte are written.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function assertWriteMaxBytes(writeMaxBytes: number, bytesWritten: number): void;
+/**
+ * Raise an error ResourceExhausted if more than readMaxBytes are read.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function assertReadMaxBytes(readMaxBytes: number, bytesRead: number, totalSizeKnown?: boolean): void;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/limit-io.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 { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+/**
+ * At most, allow ~4GiB to be received or sent per message.
+ * zlib used by Node.js caps maxOutputLength at this value. It also happens to
+ * be the maximum theoretical message size supported by protobuf-es.
+ */
+const maxReadMaxBytes = 0xffffffff;
+const maxWriteMaxBytes = maxReadMaxBytes;
+/**
+ * The default value for the compressMinBytes option. The CPU cost of compressing
+ * very small messages usually isn't worth the small reduction in network I/O, so
+ * the default value is 1 kibibyte.
+ */
+const defaultCompressMinBytes = 1024;
+/**
+ * Asserts that the options writeMaxBytes, readMaxBytes, and compressMinBytes
+ * are within sane limits, and returns default values where no value is
+ * provided.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateReadWriteMaxBytes(readMaxBytes, writeMaxBytes, compressMinBytes) {
+    writeMaxBytes !== null && writeMaxBytes !== void 0 ? writeMaxBytes : (writeMaxBytes = maxWriteMaxBytes);
+    readMaxBytes !== null && readMaxBytes !== void 0 ? readMaxBytes : (readMaxBytes = maxReadMaxBytes);
+    compressMinBytes !== null && compressMinBytes !== void 0 ? compressMinBytes : (compressMinBytes = defaultCompressMinBytes);
+    if (writeMaxBytes < 1 || writeMaxBytes > maxWriteMaxBytes) {
+        throw new ConnectError(`writeMaxBytes ${writeMaxBytes} must be >= 1 and <= ${maxWriteMaxBytes}`, Code.Internal);
+    }
+    if (readMaxBytes < 1 || readMaxBytes > maxReadMaxBytes) {
+        throw new ConnectError(`readMaxBytes ${readMaxBytes} must be >= 1 and <= ${maxReadMaxBytes}`, Code.Internal);
+    }
+    return {
+        readMaxBytes,
+        writeMaxBytes,
+        compressMinBytes,
+    };
+}
+/**
+ * Raise an error ResourceExhausted if more than writeMaxByte are written.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function assertWriteMaxBytes(writeMaxBytes, bytesWritten) {
+    if (bytesWritten > writeMaxBytes) {
+        throw new ConnectError(`message size ${bytesWritten} is larger than configured writeMaxBytes ${writeMaxBytes}`, Code.ResourceExhausted);
+    }
+}
+/**
+ * Raise an error ResourceExhausted if more than readMaxBytes are read.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function assertReadMaxBytes(readMaxBytes, bytesRead, totalSizeKnown = false) {
+    if (bytesRead > readMaxBytes) {
+        let message = `message size is larger than configured readMaxBytes ${readMaxBytes}`;
+        if (totalSizeKnown) {
+            message = `message size ${bytesRead} is larger than configured readMaxBytes ${readMaxBytes}`;
+        }
+        throw new ConnectError(message, Code.ResourceExhausted);
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { PartialMessage, MessageType } from "@bufbuild/protobuf";
+import { Message } from "@bufbuild/protobuf";
+/**
+ *  Takes a partial protobuf messages of the
+ *  specified message type as input, and returns full instances.
+ */
+export declare function normalize<T extends Message<T>>(type: MessageType<T>, message: T | PartialMessage<T>): T;
+/**
+ * Takes an AsyncIterable of partial protobuf messages of the
+ * specified message type as input, and yields full instances.
+ */
+export declare function normalizeIterable<T extends Message<T>>(messageType: MessageType<T>, input: AsyncIterable<T | PartialMessage<T>>): AsyncIterable<T>;

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

@@ -0,0 +1,53 @@
+// 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 } from "@bufbuild/protobuf";
+/**
+ *  Takes a partial protobuf messages of the
+ *  specified message type as input, and returns full instances.
+ */
+export function normalize(type, message) {
+    return message instanceof type
+        ? message
+        : new type(message);
+}
+/**
+ * Takes an AsyncIterable of partial protobuf messages of the
+ * specified message type as input, and yields full instances.
+ */
+export function normalizeIterable(messageType, input) {
+    function transform(result) {
+        if (result.done === true) {
+            return result;
+        }
+        return {
+            done: result.done,
+            value: normalize(messageType, result.value),
+        };
+    }
+    return {
+        [Symbol.asyncIterator]() {
+            const it = input[Symbol.asyncIterator]();
+            const res = {
+                next: () => it.next().then(transform),
+            };
+            if (it.throw !== undefined) {
+                res.throw = (e) => it.throw(e).then(transform); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            }
+            if (it.return !== undefined) {
+                res.return = (v) => it.return(v).then(transform); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            }
+            return res;
+        },
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { MethodImplSpec } from "../implementation.js";
+import type { UniversalHandler } from "./universal-handler.js";
+/**
+ * Creates a handler function for an RPC definition and an RPC implementation,
+ * for one specific protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface ProtocolHandlerFactory {
+    /**
+     * Create a new handler with the user-provided implementation of the procedure.
+     */
+    (spec: MethodImplSpec): UniversalHandler;
+    /**
+     * The name of the protocol that the created handlers implement.
+     */
+    protocolName: string;
+}

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

@@ -0,0 +1,14 @@
+// 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 {};

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

@@ -0,0 +1,45 @@
+import type { AnyMessage, Message, PartialMessage } from "@bufbuild/protobuf";
+import type { Interceptor, StreamRequest, StreamResponse, UnaryRequest, UnaryResponse } from "../interceptor.js";
+/**
+ * UnaryFn represents the client-side invocation of a unary RPC - a method
+ * that takes a single input message, and responds with a single output
+ * message.
+ * A Transport implements such a function, and makes it available to
+ * interceptors.
+ */
+type UnaryFn<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = (req: UnaryRequest<I, O>) => Promise<UnaryResponse<I, O>>;
+/**
+ * Runs a unary method with the given interceptors. Note that this function
+ * is only used when implementing a Transport.
+ */
+export declare function runUnaryCall<I extends Message<I>, O extends Message<O>>(opt: {
+    req: Omit<UnaryRequest<I, O>, "signal" | "message"> & {
+        message: PartialMessage<I>;
+    };
+    next: UnaryFn<I, O>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    interceptors?: Interceptor[];
+}): Promise<UnaryResponse<I, O>>;
+/**
+ * StreamingFn represents the client-side invocation of a streaming RPC - a
+ * method that takes zero or more input messages, and responds with zero or
+ * more output messages.
+ * A Transport implements such a function, and makes it available to
+ * interceptors.
+ */
+type StreamingFn<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = (req: StreamRequest<I, O>) => Promise<StreamResponse<I, O>>;
+/**
+ * Runs a server-streaming method with the given interceptors. Note that this
+ * function is only used when implementing a Transport.
+ */
+export declare function runStreamingCall<I extends Message<I>, O extends Message<O>>(opt: {
+    req: Omit<StreamRequest<I, O>, "signal" | "message"> & {
+        message: AsyncIterable<PartialMessage<I>>;
+    };
+    next: StreamingFn<I, O>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    interceptors?: Interceptor[];
+}): Promise<StreamResponse<I, O>>;
+export {};

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

@@ -0,0 +1,115 @@
+// 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 { applyInterceptors } from "../interceptor.js";
+import { ConnectError } from "../connect-error.js";
+import { createDeadlineSignal, createLinkedAbortController, getAbortSignalReason, } from "./signals.js";
+import { normalize, normalizeIterable } from "./normalize.js";
+/**
+ * Runs a unary method with the given interceptors. Note that this function
+ * is only used when implementing a Transport.
+ */
+export function runUnaryCall(opt) {
+    const next = applyInterceptors(opt.next, opt.interceptors);
+    const [signal, abort, done] = setupSignal(opt);
+    const req = Object.assign(Object.assign({}, opt.req), { message: normalize(opt.req.method.I, opt.req.message), signal });
+    return next(req).then((res) => {
+        done();
+        return res;
+    }, abort);
+}
+/**
+ * Runs a server-streaming method with the given interceptors. Note that this
+ * function is only used when implementing a Transport.
+ */
+export function runStreamingCall(opt) {
+    const next = applyInterceptors(opt.next, opt.interceptors);
+    const [signal, abort, done] = setupSignal(opt);
+    const req = Object.assign(Object.assign({}, opt.req), { message: normalizeIterable(opt.req.method.I, opt.req.message), signal });
+    let doneCalled = false;
+    // Call return on the request iterable to indicate
+    // that we will no longer consume it and it should
+    // cleanup any allocated resources.
+    signal.addEventListener("abort", function () {
+        var _a, _b;
+        const it = opt.req.message[Symbol.asyncIterator]();
+        // If the signal is aborted due to an error, we want to throw
+        // the error to the request iterator.
+        if (!doneCalled) {
+            (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, this.reason).catch(() => {
+                // throw returns a promise, which we don't care about.
+                //
+                // Uncaught promises are thrown at sometime/somewhere by the event loop,
+                // this is to ensure error is caught and ignored.
+            });
+        }
+        (_b = it.return) === null || _b === void 0 ? void 0 : _b.call(it).catch(() => {
+            // return returns a promise, which we don't care about.
+            //
+            // Uncaught promises are thrown at sometime/somewhere by the event loop,
+            // this is to ensure error is caught and ignored.
+        });
+    });
+    return next(req).then((res) => {
+        return Object.assign(Object.assign({}, res), { message: {
+                [Symbol.asyncIterator]() {
+                    const it = res.message[Symbol.asyncIterator]();
+                    return {
+                        next() {
+                            return it.next().then((r) => {
+                                if (r.done == true) {
+                                    doneCalled = true;
+                                    done();
+                                }
+                                return r;
+                            }, abort);
+                        },
+                        // We deliberately omit throw/return.
+                    };
+                },
+            } });
+    }, abort);
+}
+/**
+ * Create an AbortSignal for Transport implementations. The signal is available
+ * in UnaryRequest and StreamingRequest, and is triggered when the call is
+ * aborted (via a timeout or explicit cancellation), errored (e.g. when reading
+ * an error from the server from the wire), or finished successfully.
+ *
+ * Transport implementations can pass the signal to HTTP clients to ensure that
+ * there are no unused connections leak.
+ *
+ * Returns a tuple:
+ * [0]: The signal, which is also aborted if the optional deadline is reached.
+ * [1]: Function to call if the Transport encountered an error.
+ * [2]: Function to call if the Transport finished without an error.
+ */
+function setupSignal(opt) {
+    const { signal, cleanup } = createDeadlineSignal(opt.timeoutMs);
+    const controller = createLinkedAbortController(opt.signal, signal);
+    return [
+        controller.signal,
+        function abort(reason) {
+            // We peek at the deadline signal because fetch() will throw an error on
+            // abort that discards the signal reason.
+            const e = ConnectError.from(signal.aborted ? getAbortSignalReason(signal) : reason);
+            controller.abort(e);
+            cleanup();
+            return Promise.reject(e);
+        },
+        function done() {
+            cleanup();
+            controller.abort();
+        },
+    ];
+}