openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect-node/dist/esm/grpc-web-transport.js

@@ -0,0 +1,22 @@
+// Copyright 2021-2026 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 { createTransport } from "@connectrpc/connect/protocol-grpc-web";
+import { validateNodeTransportOptions, } from "./node-transport-options.js";
+/**
+ * Create a Transport for the gRPC-web protocol using the Node.js `http`,
+ * `https`, or `http2` module.
+ */
+export function createGrpcWebTransport(options) {
+    return createTransport(validateNodeTransportOptions(options));
+}

package/node_modules/@connectrpc/connect-node/dist/esm/http2-session-manager.d.ts

@@ -0,0 +1,146 @@
+import * as http2 from "node:http2";
+export interface Http2SessionOptions {
+    /**
+     * The interval to send PING frames to keep a connection alive. The interval
+     * is reset whenever a stream receives data. If a PING frame is not responded
+     * to within pingTimeoutMs, the connection and all open streams close.
+     *
+     * By default, no PING frames are sent. If a value is provided, PING frames
+     * are sent only for connections that have open streams, unless
+     * pingIdleConnections is enabled.
+     *
+     * Sensible values can be between 10 seconds and 2 hours, depending on your
+     * infrastructure.
+     *
+     * This option is equivalent to GRPC_ARG_KEEPALIVE_TIME_MS in gRPC Core.
+     */
+    pingIntervalMs?: number;
+    /**
+     * Enable PING frames for connections that are have no open streams.
+     * This option is only effective if a value for pingIntervalMs is provided.
+     *
+     * Note that it may not be necessary to enable this option. If a request is
+     * made on a connection that has not been used for longer than pingIntervalMs,
+     * a PING frame is sent to verify that the connection is still alive, and a
+     * new connection is opened transparently if necessary.
+     *
+     * Defaults to false.
+     *
+     * This option is equivalent to GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS in
+     * gRPC Core.
+     */
+    pingIdleConnection?: boolean;
+    /**
+     * Timeout for PING frames. If a PING is not answered within this time, the
+     * connection is considered dead.
+     *
+     * Defaults to 15 seconds. This option is only used if a value for
+     * pingIntervalMs is provided.
+     *
+     * This option is equivalent to GRPC_ARG_KEEPALIVE_TIMEOUT_MS in gRPC Core.
+     */
+    pingTimeoutMs?: number;
+    /**
+     * Automatically close a connection if the time since the last request stream
+     * exceeds this value.
+     *
+     * Defaults to 15 minutes.
+     *
+     * This option is equivalent to GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS of gRPC core.
+     */
+    idleConnectionTimeoutMs?: number;
+}
+/**
+ * Manage an HTTP/2 connection and keep it alive with PING frames.
+ *
+ * The logic is based on "Basic Keepalive" described in
+ * https://github.com/grpc/proposal/blob/0ba0c1905050525f9b0aee46f3f23c8e1e515489/A8-client-side-keepalive.md#basic-keepalive
+ * as well as the client channel arguments described in
+ * https://github.com/grpc/grpc/blob/8e137e524a1b1da7bbf4603662876d5719563b57/doc/keepalive.md
+ *
+ * Usually, the managers tracks exactly one connection, but if a connection
+ * receives a GOAWAY frame with NO_ERROR, the connection is maintained until
+ * all streams have finished, and new requests will open a new connection.
+ */
+export declare class Http2SessionManager {
+    /**
+     * The host this session manager connect to.
+     */
+    authority: string;
+    /**
+     * The current state of the connection:
+     *
+     * - "closed"
+     *   The connection is closed, or no connection has been opened yet.
+     * - connecting
+     *   Currently establishing a connection.
+     *
+     * - "open"
+     *   A connection is open and has open streams. PING frames are sent every
+     *   pingIntervalMs, unless a stream received data.
+     *   If a PING frame is not responded to within pingTimeoutMs, the connection
+     *   and all open streams close.
+     *
+     * - "idle"
+     *   A connection is open, but it does not have any open streams.
+     *   If pingIdleConnection is enabled, PING frames are used to keep the
+     *   connection alive, similar to an "open" connection.
+     *   If a connection is idle for longer than idleConnectionTimeoutMs, it closes.
+     *   If a request is made on an idle connection that has not been used for
+     *   longer than pingIntervalMs, the connection is verified.
+     *
+     * - "verifying"
+     *   Verifying a connection after a long period of inactivity before issuing a
+     *   request. A PING frame is sent, and if it times out within pingTimeoutMs, a
+     *   new connection is opened.
+     *
+     * - "error"
+     *   The connection is closed because of a transient error. A connection
+     *   may have failed to reach the host, or the connection may have died,
+     *   or it may have been aborted.
+     */
+    state(): "closed" | "connecting" | "open" | "idle" | "verifying" | "error";
+    /**
+     * Returns the error object if the connection is in the "error" state,
+     * `undefined` otherwise.
+     */
+    error(): unknown;
+    private s;
+    private shuttingDown;
+    private readonly http2SessionOptions;
+    private readonly options;
+    private verifying;
+    constructor(url: URL | string, pingOptions?: Http2SessionOptions, http2SessionOptions?: http2.ClientSessionOptions | http2.SecureClientSessionOptions);
+    /**
+     * Open a connection if none exists, verify an existing connection if
+     * necessary.
+     */
+    connect(): Promise<"open" | "idle" | "error">;
+    /**
+     * Issue a request.
+     *
+     * This method automatically opens a connection if none exists, and verifies
+     * an existing connection if necessary. It calls http2.ClientHttp2Session.request(),
+     * and keeps track of all open http2.ClientHttp2Stream.
+     *
+     * Clients must call notifyResponseByteRead() whenever they successfully read
+     * data from the http2.ClientHttp2Stream.
+     */
+    request(method: string, path: string, headers: http2.OutgoingHttpHeaders, options: Omit<http2.ClientSessionRequestOptions, "signal">): Promise<http2.ClientHttp2Stream>;
+    /**
+     * Notify the manager of a successful read from a http2.ClientHttp2Stream.
+     *
+     * Clients must call this function whenever they successfully read data from
+     * a http2.ClientHttp2Stream obtained from request(). This informs the
+     * keep-alive logic that the connection is alive, and prevents it from sending
+     * unnecessary PING frames.
+     */
+    notifyResponseByteRead(stream: http2.ClientHttp2Stream): void;
+    /**
+     * If there is an open connection, close it. This also closes any open streams.
+     */
+    abort(reason?: Error): void;
+    private gotoReady;
+    private setState;
+    private verify;
+}