grpc-dc 0.0.0-stage → 0.31.0

package/src/webrtc_direct.js

@@ -0,0 +1,119 @@
+// @generated by grpc-dc codegen. DO NOT EDIT.
+// SPDX-License-Identifier: Apache-2.0
+// WebRTC-Direct (libp2p-style) client->server helpers for Node:
+// no ICE, no SDP exchange. The listener is identified by the
+// certhash in its multiaddr; dialers pin the listener
+// certificate to it. The TURN variant is the symmetric-NAT path
+// (the whole DTLS session rides a TURN allocation). This is the
+// generated-runtime adapter over the hand-written stack in
+// webrtc/js/direct.js -- the same shape as the Rust
+// `grpc_dc::webrtc_direct` module and the Go adapter
+// `go/webrtc_direct.go`. Browsers cannot bind UDP: in the
+// browser, use createPeer with a native RTCPeerConnection's
+// relay-only datachannel instead.
+
+import {
+  DirectListener,
+  directDialMultiaddr,
+  directDialTurnMultiaddr,
+} from "../../webrtc/js/direct.js";
+import { Endpoint } from "./endpoint.js";
+
+export { DirectListener };
+
+/** Bind a WebRTC-Direct listener (multiaddr() is its identity). */
+export async function directListener(options = {}) {
+  return DirectListener.bind(options);
+}
+
+function waitForChannel(endpoint, timeoutMs = 30000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error("webrtc-direct: no channel opened")),
+      timeoutMs,
+    );
+    endpoint.onchannel = (channel) => {
+      clearTimeout(timer);
+      resolve(channel);
+    };
+  });
+}
+
+/**
+ * Accept one direct connection and its "grpc" channel; serve
+ * the returned Endpoint with `new Server().serve(endpoint)` or
+ * register services on it. The server side answers with even
+ * stream ids.
+ */
+export async function acceptDirectEndpoint(listener) {
+  const endpoint = await listener.accept();
+  const channel = await waitForChannel(endpoint);
+  const grpcEndpoint = new Endpoint(channel, { parity: "even" });
+  // The underlying stack endpoint, for close()/transport
+  // control; the generated Endpoint wraps only the channel.
+  grpcEndpoint.directEndpoint = endpoint;
+  return grpcEndpoint;
+}
+
+/**
+ * Dial a Direct listener by multiaddr and open the "grpc"
+ * channel; build a generated client with
+ * `new Channel(await directClientEndpoint(ma))`. The dialer
+ * allocates odd stream ids.
+ */
+export async function directClientEndpoint(multiaddr, options = {}) {
+  const endpoint = await directDialMultiaddr(multiaddr, options);
+  const channel = endpoint.openChannel({ label: "grpc" });
+  const grpcEndpoint = new Endpoint(channel, { parity: "odd" });
+  grpcEndpoint.directEndpoint = endpoint;
+  return grpcEndpoint;
+}
+
+/**
+ * Dial a Direct listener by multiaddr and return the raw stack
+ * endpoint (no channel opened yet), plus the TURN variant. Use
+ * these to open extra application channels next to the "grpc"
+ * one -- including lossy or unordered ones, via
+ * `endpoint.openChannel({ label, ordered: false,
+ * reliability: { kind: "retransmits", count: n } })` (or
+ * `{ kind: "lifetime", ms }`). The "grpc" channel itself must
+ * stay reliable and ordered: grpc-dc framing assumes in-order
+ * reliable delivery, so keep directClientEndpoint's defaults
+ * for gRPC traffic and use lossy channels only for application
+ * data that tolerates drops and reordering. Incoming
+ * application channels surface as `endpoint.onchannel`.
+ */
+export async function directClientStackEndpoint(multiaddr, options = {}) {
+  return directDialMultiaddr(multiaddr, options);
+}
+
+export async function directClientTurnStackEndpoint(multiaddr, turn, options = {}) {
+  return directDialTurnMultiaddr(multiaddr, { ...options, turn });
+}
+
+/**
+ * Open an extra application channel on a stack endpoint from
+ * directClientStackEndpoint / acceptDirectEndpoint's
+ * directEndpoint. `params` is the stack ChannelParams shape:
+ * { label, ordered?, reliability? } -- see
+ * directClientStackEndpoint for lossy/unordered options.
+ */
+export function openDirectChannel(stackEndpoint, params = {}) {
+  return stackEndpoint.openChannel(params);
+}
+
+/**
+ * Dial by multiaddr through a TURN allocation (symmetric-NAT
+ * path). `turn` is {address, username, password, transport?,
+ * insecureSkipVerify?, requestIpv6Relay?}.
+ */
+export async function directClientTurnEndpoint(multiaddr, turn, options = {}) {
+  const endpoint = await directDialTurnMultiaddr(multiaddr, {
+    ...options,
+    turn,
+  });
+  const channel = endpoint.openChannel({ label: "grpc" });
+  const grpcEndpoint = new Endpoint(channel, { parity: "odd" });
+  grpcEndpoint.directEndpoint = endpoint;
+  return grpcEndpoint;
+}

package/wire_gen.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// @generated by grpc-dc codegen. DO NOT EDIT.
+
+export const FrameType = {
+  HEADERS: 1, // call headers, JSON {path, metadata}
+  DATA: 2, // one serialized protobuf message
+  TRAILERS: 3, // terminal status, JSON {code, message}
+  HALF_CLOSE: 4, // client finished sending
+  RST: 5, // abort stream, JSON {code, message}
+};
+
+export const StatusCode = {
+  OK: 0,
+  CANCELLED: 1,
+  UNKNOWN: 2,
+  INVALID_ARGUMENT: 3,
+  DEADLINE_EXCEEDED: 4,
+  NOT_FOUND: 5,
+  ALREADY_EXISTS: 6,
+  PERMISSION_DENIED: 7,
+  RESOURCE_EXHAUSTED: 8,
+  FAILED_PRECONDITION: 9,
+  ABORTED: 10,
+  OUT_OF_RANGE: 11,
+  UNIMPLEMENTED: 12,
+  INTERNAL: 13,
+  UNAVAILABLE: 14,
+  DATA_LOSS: 15,
+  UNAUTHENTICATED: 16,
+};
+
+export const StatusName = {
+  0: "OK",
+  1: "CANCELLED",
+  2: "UNKNOWN",
+  3: "INVALID-ARGUMENT",
+  4: "DEADLINE-EXCEEDED",
+  5: "NOT-FOUND",
+  6: "ALREADY-EXISTS",
+  7: "PERMISSION-DENIED",
+  8: "RESOURCE-EXHAUSTED",
+  9: "FAILED-PRECONDITION",
+  10: "ABORTED",
+  11: "OUT-OF-RANGE",
+  12: "UNIMPLEMENTED",
+  13: "INTERNAL",
+  14: "UNAVAILABLE",
+  15: "DATA-LOSS",
+  16: "UNAUTHENTICATED",
+};