Cannot create quic http/3 connection using URL

[SchoolTARMaster]

@jasnell
@nodejs

NodeJS versions: I did this in v27.0.0-pre, but it happens on any version that supports quic.
I noticed here this block of code, which was used as part of an example for an http/3 client:

const session = await connect('example.com:443', {
  // ALPN defaults to 'h3'.
  servername: 'example.com',
});
await session.opened;

If I try to call quic.connect(), whether I have the intention to use http/3 or raw quic, if I set the address parameter of the function to a URL instead of an IP address, it throws an error. But in the block of code I showed, it just uses 'example.com:443'. This can be a problem because some websites change the IP every few minutes, so then it would be mandatory to perform a DNS lookup.
Thank you

[jasnell]

The implementation currently does not perform DNS resolution of the address. It's a known limitation that is intentional for now... I wanted to focus on minimizing what additional work is happening at this layer while we figure out all the details.

[SchoolTARMaster]

Ok thanks @jasnell . But I also found another issue, and I don't know if this one is exclusive to github codespaces, but basically when I ran this script with --experimental-quic and NODE_DEBUG=quic

const quic = require("node:quic");
(async () => {
    const client = await quic.connect("15.204.239.204:443", {
        servername: "browser.rammerhead.org",
        alpn: "h3",
        protocol: "h3"
    });
    await client.opened;
    const stream = client.createBidirectionalStream({
        headers: {
            ":authority": "browser.rammerhead.org",
            ":method": "GET",
            ":scheme": "https",
            ":path": "/"
        },
        onheaders(headers) {
            console.log(headers);
        }
    });
    await stream.closed;
})();

Here are the logs:

QUIC 2959: endpoint created
QUIC 2959: endpoint connecting as a client
QUIC 2959: session created
(node:2959) ExperimentalWarning: quic is an experimental feature and might change at any time
(Use `node --trace-warnings ...` to show where the warning was created)
QUIC 2959: session close callback 3 0n undefined
QUIC 2959: finishing closing the session with no error
QUIC 2959: destroying the session
node:internal/quic/quic:3372
      this.#pendingOpen.reject(error ?? new ERR_INVALID_STATE(
                                        ^

Error [ERR_INVALID_STATE]: Invalid state: Session was destroyed before it opened
    at QuicSession.destroy (node:internal/quic/quic:3372:41)
    at [kFinishClose] (node:internal/quic/quic:3471:12)
    at Session.onSessionClose (node:internal/quic/quic:679:31) {
  code: 'ERR_INVALID_STATE'
}

Node.js v27.0.0-pre

The interesting thing is that it says the session was closed, then it attempted to destroy it, but then there's an error that says that it was destroyed before it opened, even though the logs said it finished closing the session.

Thanks again

[SchoolTARMaster]

@jasnell Another thing is that when running this script on the codespace

const quic = require("node:quic");
const { readFileSync } = require("node:fs");
const { createPrivateKey } = require("node:crypto");
const cert = readFileSync("./cert.pem");
const key = createPrivateKey(readFileSync("./key.pem"));
(async () => {
    const server = await quic.listen(() => {}, {
        rejectUnauthorized: false,
        alpn: ["h3"],
        endpoint: new quic.QuicEndpoint({
            address: "127.0.0.1:443"
        }),
        sni: {
            "*": { keys: key, certs: cert }
        },
        onheaders() {
            this.sendHeaders({
                ":status": "200",
                "content-type": "text/plain"
            });
            this.writer.endSync();
        }
    });
    const client = await quic.connect("127.0.0.1:443", {
        servername: "127.0.0.1",
        alpn: "h3",
        protocol: "h3"
    });
    const stream = client.createBidirectionalStream({
        headers: {
            ":authority": "127.0.0.1",
            ":method": "GET",
            ":scheme": "https",
            ":path": "/"
        },
        onheaders(headers) {
            console.log(headers);
        }
    });
    await stream.closed;
})();

(I ran it with sudo as I need root permissions to listen on port 443)

The logs don't show an error

(node:50672) ExperimentalWarning: quic is an experimental feature and might change at any time
(Use `node --trace-warnings ...` to show where the warning was created)
(node:50672) Warning: A new stream was received but no onstream callback was provided
(node:50672) Warning: A new stream was received but no onstream callback was provided

But the headers never show up in the console.
Thank you

[jasnell]

Yeah I think what's likely happening is something is stopping the connection from establishing. Will have to investigate and work through the ergonomics of how these failure cases are handled.

[SchoolTARMaster]

@jasnell This is on github codespaces, and I'm not sure whether it can connect to an external server. But then also the local server and client didn't work.

[SchoolTARMaster]

And for some reason running the script on replit

const quic = require("node:quic");
const { readFileSync } = require("node:fs");
const { createPrivateKey } = require("node:crypto");
const cert = readFileSync("./cert.pem");
const key = createPrivateKey(readFileSync("./key.pem"));
(async () => {
    const server = await quic.listen((session) => {
        console.log("Server: session received.");
        session.onstream = () => {
            console.log("Server: stream received.");
        };
    }, {
        rejectUnauthorized: false,
        alpn: ["h3"],
        endpoint: new quic.QuicEndpoint({
            address: "127.0.0.1:443"
        }),
        sni: {
            "*": { keys: key, certs: cert }
        },
        onheaders(headers) {
            console.log(headers);
            this.sendHeaders({
                ":status": "200",
                "content-type": "text/plain"
            });
            this.writer.endSync();
        }
    });
    const client = await quic.connect("127.0.0.1:443", {
        servername: "127.0.0.1",
        alpn: "h3",
        protocol: "h3"
    });
    console.log("Client: session created.");
    const stream = await client.createBidirectionalStream({
        headers: {
            ":authority": "127.0.0.1",
            ":method": "GET",
            ":scheme": "https",
            ":path": "/"
        },
        onheaders(headers) {
            console.log(headers);
        }
    });
    console.log("Client: stream created.");
    await stream.closed;
})();

Shows more promising logs

(node:1964) ExperimentalWarning: quic is an experimental feature and might change at any time
(Use `node --trace-warnings ...` to show where the warning was created)
Client: session created.
Client: stream created.
Server: session received.
Server: stream received.
[Object: null prototype] {
  ':authority': '127.0.0.1',
  ':method': 'GET',
  ':scheme': 'https',
  ':path': '/'
}
[Object: null prototype] {
  ':status': '200',
  'content-type': 'text/plain'
}

[github-actions]

This issue has been marked as stale due to 90 days of inactivity.
It will be automatically closed in 30 days if no further activity occurs. If this is still relevant, please leave a comment or update it to keep it open.

[github-actions]

This issue has been automatically closed after 30 days of inactivity following its stale status (no activity for a total of 120 days).
If this is still relevant, feel free to reopen it or leave a comment with additional details so we can continue the discussion.