@qubic.ts/core 0.1.0

package/src/transport/bridge.ts

@@ -0,0 +1,178 @@
+import { AsyncQueue } from "./async-queue.js";
+import type { Transport } from "./transport.js";
+
+export type BridgeWebSocketLike = Readonly<{
+  readonly readyState: number;
+  readonly CONNECTING: number;
+  readonly OPEN: number;
+  readonly CLOSING: number;
+  readonly CLOSED: number;
+  binaryType?: string;
+
+  send(data: Uint8Array): void;
+  close(code?: number, reason?: string): void;
+  addEventListener(
+    type: "open" | "message" | "error" | "close",
+    listener: (event: unknown) => void,
+    options?: Readonly<{ once?: boolean }>,
+  ): void;
+  removeEventListener(
+    type: "open" | "message" | "error" | "close",
+    listener: (event: unknown) => void,
+  ): void;
+}>;
+
+export type BridgeWebSocketConstructor = new (url: string) => BridgeWebSocketLike;
+
+export type CreateBridgeTransportOptions = Readonly<{
+  url: string;
+  signal?: AbortSignal;
+  WebSocketImpl?: BridgeWebSocketConstructor;
+}>;
+
+function toAbortError(reason: unknown): Error {
+  if (reason instanceof Error) return reason;
+  const error = new Error("Aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function toUint8ArrayMessage(data: unknown): Uint8Array {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    const view = data as ArrayBufferView;
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+  }
+  throw new TypeError("WebSocket message must be binary (Uint8Array/ArrayBuffer)");
+}
+
+export async function createBridgeTransport(
+  options: CreateBridgeTransportOptions,
+): Promise<Transport> {
+  const WebSocketImpl =
+    options.WebSocketImpl ??
+    (globalThis as unknown as Readonly<{ WebSocket?: BridgeWebSocketConstructor }>).WebSocket;
+  if (!WebSocketImpl) {
+    throw new Error(
+      "WebSocket implementation not found; pass WebSocketImpl or run in a WebSocket-capable runtime",
+    );
+  }
+
+  const ws = new WebSocketImpl(options.url);
+  if ("binaryType" in ws) {
+    try {
+      (ws as unknown as { binaryType?: string }).binaryType = "arraybuffer";
+    } catch {
+      // ignore
+    }
+  }
+
+  const queue = new AsyncQueue<Uint8Array>();
+
+  const onMessage = (event: unknown) => {
+    try {
+      const data = (event as { data?: unknown } | null | undefined)?.data;
+      queue.push(toUint8ArrayMessage(data));
+    } catch (err) {
+      queue.error(err);
+      try {
+        ws.close();
+      } catch {
+        // ignore
+      }
+    }
+  };
+
+  const onError = () => {
+    queue.error(new Error("WebSocket error"));
+  };
+
+  const onClose = () => {
+    queue.close();
+  };
+
+  ws.addEventListener("message", onMessage);
+  ws.addEventListener("error", onError);
+  ws.addEventListener("close", onClose);
+
+  const abortListener = () => {
+    const err = toAbortError(options.signal?.reason);
+    queue.error(err);
+    try {
+      ws.close();
+    } catch {
+      // ignore
+    }
+  };
+  if (options.signal) {
+    if (options.signal.aborted) abortListener();
+    else options.signal.addEventListener("abort", abortListener, { once: true });
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    const onOpen = () => {
+      cleanup();
+      resolve();
+    };
+    const onOpenError = () => {
+      cleanup();
+      reject(new Error("WebSocket connection failed"));
+    };
+    const cleanup = () => {
+      ws.removeEventListener("open", onOpen);
+      ws.removeEventListener("error", onOpenError);
+    };
+
+    if (ws.readyState === ws.OPEN) {
+      cleanup();
+      resolve();
+      return;
+    }
+    if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
+      cleanup();
+      reject(new Error("WebSocket is closed"));
+      return;
+    }
+
+    ws.addEventListener("open", onOpen, { once: true });
+    ws.addEventListener("error", onOpenError, { once: true });
+  });
+
+  const write = async (bytes: Uint8Array): Promise<void> => {
+    if (!(bytes instanceof Uint8Array)) {
+      throw new TypeError("bytes must be a Uint8Array");
+    }
+    if (ws.readyState !== ws.OPEN) {
+      throw new Error("WebSocket is not open");
+    }
+    ws.send(bytes);
+  };
+
+  const close = async (): Promise<void> => {
+    if (options.signal) options.signal.removeEventListener("abort", abortListener);
+    if (ws.readyState === ws.CLOSED) {
+      queue.close();
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      const onClosed = () => {
+        ws.removeEventListener("close", onClosed);
+        resolve();
+      };
+      ws.addEventListener("close", onClosed);
+      try {
+        ws.close();
+      } catch {
+        resolve();
+      }
+    });
+  };
+
+  return {
+    read: () => queue,
+    write,
+    close,
+  };
+}

package/src/transport/tcp.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import net from "node:net";
+import { createTcpTransport } from "./tcp.js";
+
+type ServerHandle = {
+  server: net.Server;
+  port: number;
+};
+
+async function startServer(
+  handler: (socket: net.Socket) => void | Promise<void>,
+): Promise<ServerHandle> {
+  const server = net.createServer((socket) => {
+    void handler(socket);
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.listen(0, "127.0.0.1", () => resolve());
+    server.once("error", reject);
+  });
+
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Failed to bind test server");
+  }
+
+  return { server, port: Number(address.port) };
+}
+
+async function stopServer(handle: ServerHandle) {
+  await new Promise<void>((resolve, reject) => {
+    handle.server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+describe("createTcpTransport", () => {
+  let handle: ServerHandle | undefined;
+
+  afterEach(async () => {
+    if (handle) {
+      await stopServer(handle);
+      handle = undefined;
+    }
+  });
+
+  it("reads chunks from the socket", async () => {
+    handle = await startServer(async (socket) => {
+      socket.write(Uint8Array.from([1, 2, 3]));
+      await new Promise((r) => setTimeout(r, 5));
+      socket.write(Uint8Array.from([4, 5]));
+      socket.end();
+    });
+
+    const transport = await createTcpTransport({ host: "127.0.0.1", port: handle.port });
+
+    const received: number[] = [];
+    for await (const chunk of transport.read()) {
+      received.push(...chunk);
+    }
+
+    expect(received).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it("writes to the socket", async () => {
+    const received: number[] = [];
+    let receivedResolve: (() => void) | undefined;
+    const receivedDone = new Promise<void>((resolve) => {
+      receivedResolve = resolve;
+    });
+
+    handle = await startServer((socket) => {
+      socket.on("data", (d) => {
+        const bytes =
+          typeof d === "string"
+            ? new TextEncoder().encode(d)
+            : new Uint8Array(d.buffer, d.byteOffset, d.byteLength);
+        received.push(...bytes);
+        receivedResolve?.();
+        socket.end();
+      });
+    });
+
+    const transport = await createTcpTransport({ host: "127.0.0.1", port: handle.port });
+    await transport.write(Uint8Array.from([9, 8, 7]));
+    await transport.close();
+
+    await receivedDone;
+    expect(received).toEqual([9, 8, 7]);
+  });
+
+  it("aborts connect with AbortSignal", async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      createTcpTransport({ host: "127.0.0.1", port: 1, signal: controller.signal }),
+    ).rejects.toBeTruthy();
+  });
+});

package/src/transport/tcp.ts

@@ -0,0 +1,134 @@
+import net from "node:net";
+import { AsyncQueue } from "./async-queue.js";
+import type { Transport } from "./transport.js";
+
+export type CreateTcpTransportOptions = Readonly<{
+  host: string;
+  port: number;
+  signal?: AbortSignal;
+}>;
+
+function toAbortError(reason: unknown): Error {
+  if (reason instanceof Error) return reason;
+  const error = new Error("Aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+export async function createTcpTransport(options: CreateTcpTransportOptions): Promise<Transport> {
+  const socket = new net.Socket();
+  socket.setNoDelay(true);
+
+  const queue = new AsyncQueue<Uint8Array>();
+
+  const onData = (chunk: Buffer) => {
+    queue.push(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+  };
+  const onError = (err: unknown) => {
+    queue.error(err);
+  };
+  const onClose = () => {
+    queue.close();
+  };
+
+  socket.on("data", onData);
+  socket.on("error", onError);
+  socket.on("close", onClose);
+
+  const abortListener = () => {
+    const err = toAbortError(options.signal?.reason);
+    socket.destroy(err);
+    queue.error(err);
+  };
+  if (options.signal) {
+    if (options.signal.aborted) {
+      abortListener();
+    } else {
+      options.signal.addEventListener("abort", abortListener, { once: true });
+    }
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    const onConnect = () => {
+      cleanup();
+      resolve();
+    };
+    const onConnectError = (err: unknown) => {
+      cleanup();
+      reject(err);
+    };
+    const cleanup = () => {
+      socket.off("connect", onConnect);
+      socket.off("error", onConnectError);
+    };
+    socket.once("connect", onConnect);
+    socket.once("error", onConnectError);
+    socket.connect(options.port, options.host);
+  });
+
+  const write = (bytes: Uint8Array): Promise<void> => {
+    if (socket.destroyed) {
+      return Promise.reject(new Error("Socket is closed"));
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      let flushed = false;
+      let drained = false;
+
+      const finalizeIfDone = () => {
+        if (flushed && drained) {
+          cleanup();
+          resolve();
+        }
+      };
+
+      const onDrain = () => {
+        drained = true;
+        finalizeIfDone();
+      };
+
+      const onWrite = (err?: Error | null) => {
+        if (err) {
+          cleanup();
+          reject(err);
+          return;
+        }
+        flushed = true;
+        finalizeIfDone();
+      };
+
+      const cleanup = () => {
+        socket.off("drain", onDrain);
+      };
+
+      const ok = socket.write(bytes, onWrite);
+      if (ok) {
+        drained = true;
+        finalizeIfDone();
+      } else {
+        socket.on("drain", onDrain);
+      }
+    });
+  };
+
+  const close = async (): Promise<void> => {
+    if (options.signal) {
+      options.signal.removeEventListener("abort", abortListener);
+    }
+
+    if (socket.destroyed) {
+      queue.close();
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      socket.end(() => resolve());
+    });
+  };
+
+  return {
+    read: () => queue,
+    write,
+    close,
+  };
+}

package/src/transport/transport.ts

@@ -0,0 +1,5 @@
+export type Transport = Readonly<{
+  read(): AsyncIterable<Uint8Array>;
+  write(bytes: Uint8Array): Promise<void>;
+  close(): Promise<void>;
+}>;